X-Chain Methods

function getBalance(
  params: GetBalanceParameters
): Promise<GetBalanceReturnType>;

interface GetBalanceParameters {
  address: string;
  assetID: string;
}

interface GetBalanceReturnType {
  balance: bigint;
  utxoIDs: {
    txID: string;
    outputIndex: number;
  }[];
}

import { createAvalancheClient } from "@avalanche-sdk/client";
import { avalanche } from "@avalanche-sdk/client/chains";

const client = createAvalancheClient({
  chain: avalanche,
  transport: { type: "http" },
});

const balance = await client.xChain.getBalance({
  address: "X-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5",
  assetID: "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z", // AVAX
});

console.log("Balance:", balance.balance);
console.log("UTXO IDs:", balance.utxoIDs);

function getAllBalances(
  params: GetAllBalancesParameters
): Promise<GetAllBalancesReturnType>;

interface GetAllBalancesParameters {
  addresses: string[];
}

interface GetAllBalancesReturnType {
  balances: Array<{
    assetID: string;
    balance: bigint;
  }>;
}

const allBalances = await client.xChain.getAllBalances({
  addresses: ["X-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5"],
});

// Iterate over all assets
allBalances.balances.forEach(({ assetID, balance }) => {
  console.log(`Asset ${assetID}: ${balance}`);
});

function getAssetDescription(
  params: GetAssetDescriptionParameters
): Promise<GetAssetDescriptionReturnType>;

interface GetAssetDescriptionParameters {
  assetID: string;
}

interface GetAssetDescriptionReturnType {
  assetID: string;
  name: string;
  symbol: string;
  denomination: number;
}

const asset = await client.xChain.getAssetDescription({
  assetID: "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z",
});

console.log("Asset name:", asset.name);
console.log("Asset symbol:", asset.symbol);
console.log("Denomination:", asset.denomination);

function getHeight(): Promise<GetHeightReturnType>;

interface GetHeightReturnType {
  height: number;
}

const height = await client.xChain.getHeight();
console.log("Current X-Chain height:", height.height);

function getBlockByHeight(
  params: GetBlockByHeightParameters
): Promise<GetBlockByHeightReturnType>;

interface GetBlockByHeightParameters {
  height: number;
  encoding?: "hex" | "json";
}

interface GetBlockByHeightReturnType {
  encoding: "hex" | "json";
  block: string | object;
}

const block = await client.xChain.getBlockByHeight({
  height: 12345,
  encoding: "hex",
});

console.log("Block data:", block.block);

function getBlock(params: GetBlockParameters): Promise<GetBlockReturnType>;

interface GetBlockParameters {
  blockId: string;
  encoding?: "hex" | "json";
}

interface GetBlockReturnType {
  encoding: "hex" | "json";
  block: string | object;
}

const block = await client.xChain.getBlock({
  blockId: "block-id-in-cb58-format",
  encoding: "hex",
});

console.log("Block:", block.block);

function getTx(params: GetTxParameters): Promise<GetTxReturnType>;

interface GetTxParameters {
  txID: string;
  encoding?: "hex" | "json";
}

interface GetTxReturnType {
  encoding: "hex" | "json";
  tx: string | object;
}

const tx = await client.xChain.getTx({
  txID: "transaction-id",
  encoding: "hex",
});

console.log("Transaction:", tx.tx);

function getTxStatus(
  params: GetTxStatusParameters
): Promise<GetTxStatusReturnType>;

interface GetTxStatusParameters {
  txID: string;
  includeReason?: boolean | true;
}

interface GetTxStatusReturnType {
  status: "Accepted" | "Processing" | "Rejected" | "Unknown";
  reason?: string;
}

const status = await client.xChain.getTxStatus({
  txID: "transaction-id",
});

if (status.status === "Accepted") {
  console.log("Transaction accepted!");
} else if (status.status === "Rejected") {
  console.log("Transaction rejected");
  if (status.reason) {
    console.log("Reason:", status.reason);
  }
} else {
  console.log("Transaction status:", status.status);
}

function getTxFee(): Promise<GetTxFeeReturnType>;

interface GetTxFeeReturnType {
  txFee: number;
  createAssetTxFee: number;
}

const fees = await client.xChain.getTxFee();

console.log("Standard transaction fee:", fees.txFee);
console.log("Create asset fee:", fees.createAssetTxFee);

function getUTXOs(params: GetUTXOsParameters): Promise<GetUTXOsReturnType>;

interface GetUTXOsParameters {
  addresses: string[];
  sourceChain?: string;
  limit?: number;
  startIndex?: {
    address: string;
    utxo: string;
  };
  encoding?: "hex";
}

interface GetUTXOsReturnType {
  numFetched: number;
  utxos: string[];
  endIndex: {
    address: string;
    utxo: string;
  };
  sourceChain?: string;
  encoding: "hex";
}

// Get first page
const utxos = await client.xChain.getUTXOs({
  addresses: ["X-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5"],
  limit: 100,
});

console.log("Number of UTXOs:", utxos.numFetched);

// Get next page if needed
if (utxos.endIndex) {
  const moreUTXOs = await client.xChain.getUTXOs({
    addresses: ["X-avax18jma8ppw3nhx5r4ap8clazz0dps7rv5ukulre5"],
    startIndex: utxos.endIndex,
    limit: 100,
  });
}

function issueTx(params: IssueTxParameters): Promise<IssueTxReturnType>;

interface IssueTxParameters {
  tx: string;
  encoding: "hex";
}

interface IssueTxReturnType {
  txID: string;
}

const txID = await client.xChain.issueTx({
  tx: "0x00000009de31b4d8b22991d51aa6aa1fc733f23a851a8c9400000000000186a0...",
  encoding: "hex",
});

console.log("Transaction ID:", txID.txID);

function buildGenesis(
  params: BuildGenesisParameters
): Promise<BuildGenesisReturnType>;

interface BuildGenesisParameters {
  networkID: number;
  genesisData: {
    name: string;
    symbol: string;
    denomination: number;
    initialState: {
      fixedCap: {
        amount: number;
        addresses: string[];
      };
    };
  };
  encoding: "hex";
}

interface BuildGenesisReturnType {
  bytes: string;
  encoding: "hex";
}

const genesis = await client.xChain.buildGenesis({
  networkID: 16,
  genesisData: {
    name: "myFixedCapAsset",
    symbol: "MFCA",
    denomination: 0,
    initialState: {
      fixedCap: {
        amount: 100000,
        addresses: ["X-custom18jma8ppw3nhx5r4ap8clazz0dps7rv5u9xde7p"],
      },
    },
  },
  encoding: "hex",
});

console.log("Genesis bytes:", genesis.bytes);