Gateway Client API

new RadixGatewayClient(config: GatewayConfig)

interface GatewayConfig {
  networkId: RadixNetwork;          // Network to connect to
  applicationName?: string;         // App name for analytics
  customEndpoint?: string;          // Custom gateway endpoint
}

const gateway = new RadixGatewayClient({
  networkId: RadixNetwork.Stokenet,
  applicationName: "MyRadixApp"
});

async getGatewayStatus(): Promise\<GatewayStatus>

const status = await gateway.getGatewayStatus();
console.log("Gateway version:", status.release_info?.version);

async getCurrentEpoch(): Promise\<number>

const epoch = await gateway.getCurrentEpoch();
console.log("Current epoch:", epoch);

async getNetworkConfiguration(): Promise\<NetworkConfig>

const config = await gateway.getNetworkConfiguration();
console.log("Network ID:", config.network_id);

async getEntityDetails(address: string): Promise\<EntityDetails>

const details = await gateway.getEntityDetails("account_tdx_...");
console.log("Entity type:", details.entity_type);

async getAccountBalances(accountAddress: string): Promise\<AccountBalancesResponse>

const balances = await gateway.getAccountBalances("account_tdx_...");
for (const item of balances.items[0].fungible_resources?.items || []) {
  console.log(`Balance: ${item.amount} of ${item.resource_address}`);
}

async getAccountTransactionHistory(
  accountAddress: string,
  options?: TransactionHistoryOptions
): Promise\<TransactionHistoryResponse>

interface TransactionHistoryOptions {
  limit?: number;           // Max transactions to return (default: 30)
  cursor?: string;          // Pagination cursor
  manifestClass?: string;   // Filter by manifest class
}

const history = await gateway.getAccountTransactionHistory("account_tdx_...", {
  limit: 10
});

history.items.forEach(tx => {
  console.log(`TX: ${tx.intent_hash} at ${tx.confirmed_at}`);
});

async submitTransaction(signedTransaction: CompiledTransaction): Promise\<TransactionSubmitResponse>

const result = await gateway.submitTransaction(signedTx);
console.log("Transaction ID:", result.duplicate || "submitted");

async getTransactionStatus(transactionId: string): Promise\<TransactionStatusResponse>

const status = await gateway.getTransactionStatus("txid_...");
console.log("Status:", status.intent_status);

async previewTransaction(
  transactionManifest: string,
  startEpochInclusive: number,
  endEpochExclusive: number,
  signer?: string
): Promise\<TransactionPreviewResponse>

const preview = await gateway.previewTransaction(
  manifest,
  epoch,
  epoch + 10,
  wallet.getPublicKey()
);
console.log("Estimated fee:", preview.receipt.fee_summary?.total_cost);

async getResourceDetails(resourceAddress: string): Promise\<ResourceDetails>

const resource = await gateway.getResourceDetails("resource_tdx_...");
console.log("Resource type:", resource.resource_type);

async getResourceMetadata(resourceAddress: string): Promise\<ResourceMetadata>

const metadata = await gateway.getResourceMetadata("resource_tdx_...");
const symbol = metadata.items.find(item => item.key === "symbol")?.value;
console.log("Token symbol:", symbol);

async getComponentDetails(componentAddress: string): Promise\<ComponentDetails>

const component = await gateway.getComponentDetails("component_tdx_...");
console.log("Component type:", component.package_address);

async getComponentState(componentAddress: string): Promise\<ComponentState>

const state = await gateway.getComponentState("component_tdx_...");
console.log("Component state:", state.state);

isValidAddress(address: string): boolean

const valid = gateway.isValidAddress("account_tdx_...");
console.log("Address valid:", valid);

getXRDResourceAddress(): string

const xrdAddress = gateway.getXRDResourceAddress();
console.log("XRD address:", xrdAddress);

try {
  const balance = await gateway.getAccountBalances("invalid_address");
} catch (error) {
  if (error.message.includes("not found")) {
    console.log("Account does not exist");
  } else if (error.message.includes("network")) {
    console.log("Network connection issue");
  } else {
    console.log("Other error:", error.message);
  }
}

// ✅ Good: Reuse the same gateway instance
const gateway = new RadixGatewayClient({ networkId: RadixNetwork.Stokenet });

// Use for multiple operations
const balance1 = await gateway.getAccountBalances(address1);
const balance2 = await gateway.getAccountBalances(address2);

// ✅ Better: Use Promise.all for parallel requests
const [balance1, balance2, epoch] = await Promise.all([
  gateway.getAccountBalances(address1),
  gateway.getAccountBalances(address2),
  gateway.getCurrentEpoch()
]);

async function robustGatewayCall<T>(
  operation: () => Promise\<T>,
  retries: number = 3
): Promise\<T> {
  for (let i = 0; i < retries; i++) {
    try {
      return await operation();
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
    }
  }
  throw new Error("Max retries exceeded");
}

// Usage
const balance = await robustGatewayCall(() => 
  gateway.getAccountBalances(address)
);