API Methods

function alias(params: AliasParameters): Promise<void>;

interface AliasParameters {
  endpoint: string;
  alias: string;
}

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

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

await client.admin.alias({
  endpoint: "bc/X",
  alias: "myAlias",
});

function aliasChain(params: AliasChainParameters): Promise<void>;

interface AliasChainParameters {
  chain: string;
  alias: string;
}

await client.admin.aliasChain({
  chain: "sV6o671RtkGBcno1FiaDbVcFv2sG5aVXMZYzKdP4VQAWmJQnM",
  alias: "myBlockchainAlias",
});

function getChainAliases(params: GetChainAliasesParameters): Promise<string[]>;

interface GetChainAliasesParameters {
  chain: string;
}

const aliases = await client.admin.getChainAliases({
  chain: "sV6o671RtkGBcno1FiaDbVcFv2sG5aVXMZYzKdP4VQAWmJQnM",
});

console.log("Chain aliases:", aliases);

function getNetworkID(): Promise<GetNetworkIDReturnType>;

interface GetNetworkIDReturnType {
  networkID: string;
}

const result = await client.info.getNetworkID();

if (result.networkID === "1") {
  console.log("Connected to Mainnet");
} else if (result.networkID === "5") {
  console.log("Connected to Fuji testnet");
}

function getNetworkName(): Promise<GetNetworkNameReturnType>;

interface GetNetworkNameReturnType {
  networkName: string;
}

const result = await client.info.getNetworkName();
console.log("Network:", result.networkName);

function getNodeVersion(): Promise<GetNodeVersionReturnType>;

interface GetNodeVersionReturnType {
  version: string;
  databaseVersion: string;
  gitCommit: string;
  vmVersions: Map<string, string>;
  rpcProtocolVersion: string;
}

const version = await client.info.getNodeVersion();
console.log("Node version:", version.version);
console.log("Database version:", version.databaseVersion);
console.log("VM versions:", Object.fromEntries(version.vmVersions));

function getNodeID(): Promise<GetNodeIDReturnType>;

interface GetNodeIDReturnType {
  nodeID: string;
  nodePOP: {
    publicKey: string;
    proofOfPossession: string;
  };
}

const nodeID = await client.info.getNodeID();
console.log("Node ID:", nodeID.nodeID);
console.log("BLS Public Key:", nodeID.nodePOP.publicKey);

function getNodeIP(): Promise<GetNodeIPReturnType>;

interface GetNodeIPReturnType {
  ip: string;
}

const result = await client.info.getNodeIP();
console.log("Node IP:", result.ip);

function getBlockchainID(
  params: GetBlockchainIDParameters
): Promise<GetBlockchainIDReturnType>;

interface GetBlockchainIDParameters {
  alias: string;
}

interface GetBlockchainIDReturnType {
  blockchainID: string;
}

const result = await client.info.getBlockchainID({ alias: "X" });
console.log("X-Chain ID:", result.blockchainID);

function getTxFee(): Promise<GetTxFeeReturnType>;

interface GetTxFeeReturnType {
  txFee: bigint;
  createAssetTxFee: bigint;
  createSubnetTxFee: bigint;
  transformSubnetTxFee: bigint;
  createBlockchainTxFee: bigint;
  addPrimaryNetworkValidatorFee: bigint;
  addPrimaryNetworkDelegatorFee: bigint;
  addSubnetValidatorFee: bigint;
  addSubnetDelegatorFee: bigint;
}

const fees = await client.info.getTxFee();
console.log("Base transaction fee:", fees.txFee);
console.log("Create asset fee:", fees.createAssetTxFee);

function getVMs(): Promise<GetVMsReturnType>;

interface GetVMsReturnType {
  vms: {
    [key: string]: string[];
  };
}

const vms = await client.info.getVMs();
console.log("Supported VMs:", vms.vms);

function isBootstrapped(
  params: IsBootstrappedParameters
): Promise<IsBootstrappedReturnType>;

interface IsBootstrappedParameters {
  chain: string;
}

interface IsBootstrappedReturnType {
  isBootstrapped: boolean;
}

const result = await client.info.isBootstrapped({ chain: "X" });

if (result.isBootstrapped) {
  console.log("X-Chain is bootstrapped");
} else {
  console.log("X-Chain is still bootstrapping");
}

function peers(params: PeersParameters): Promise<PeersReturnType>;

interface PeersParameters {
  nodeIDs?: string[];
}

interface PeersReturnType {
  numPeers: number;
  peers: {
    ip: string;
    publicIP: string;
    nodeID: string;
    version: string;
    lastSent: string;
    lastReceived: string;
    benched: string[];
    observedUptime: number;
  }[];
}

const peers = await client.info.peers();
console.log("Number of peers:", peers.numPeers);
console.log("Peer details:", peers.peers);

function uptime(): Promise<UptimeReturnType>;

interface UptimeReturnType {
  rewardingStakePercentage: number;
  weightedAveragePercentage: number;
}

const uptime = await client.info.uptime();
console.log("Rewarding stake percentage:", uptime.rewardingStakePercentage);
console.log("Weighted average percentage:", uptime.weightedAveragePercentage);

function upgrades(): Promise<UpgradesReturnType>;

interface UpgradesReturnType {
  apricotPhase1Time: string;
  apricotPhase2Time: string;
  apricotPhase3Time: string;
  apricotPhase4Time: string;
  apricotPhase4MinPChainHeight: number;
  apricotPhase5Time: string;
  apricotPhasePre6Time: string;
  apricotPhase6Time: string;
  apricotPhasePost6Time: string;
  banffTime: string;
  cortinaTime: string;
  cortinaXChainStopVertexID: string;
  durangoTime: string;
  etnaTime: string;
  fortunaTime?: string;
}

const upgrades = await client.info.upgrades();
console.log("Apricot Phase 1:", upgrades.apricotPhase1Time);
console.log("Banff upgrade:", upgrades.banffTime);

function acps(): Promise<AcpsReturnType>;

interface AcpsReturnType {
  acps: Map<
    number,
    {
      supportWeight: bigint;
      supporters: Set<string>;
      objectWeight: bigint;
      objectors: Set<string>;
      abstainWeight: bigint;
    }
  >;
}

const acps = await client.info.acps();
console.log("ACP preferences:", acps.acps);

function health(params: HealthParameters): Promise<HealthReturnType>;

interface HealthParameters {
  tags?: string[];
}

interface HealthReturnType {
  healthy: boolean;
  checks: {
    C: ChainHealthCheck;
    P: ChainHealthCheck;
    X: ChainHealthCheck;
    bootstrapped: {
      message: any[];
      timestamp: string;
      duration: number;
    };
    database: {
      timestamp: string;
      duration: number;
    };
    diskspace: {
      message: {
        availableDiskBytes: number;
      };
      timestamp: string;
      duration: number;
    };
    network: {
      message: {
        connectedPeers: number;
        sendFailRate: number;
        timeSinceLastMsgReceived: string;
        timeSinceLastMsgSent: string;
      };
      timestamp: string;
      duration: number;
    };
    router: {
      message: {
        longestRunningRequest: string;
        outstandingRequests: number;
      };
      timestamp: string;
      duration: number;
    };
  };
}

type ChainHealthCheck = {
  message: {
    engine: {
      consensus: {
        lastAcceptedHeight: number;
        lastAcceptedID: string;
        longestProcessingBlock: string;
        processingBlocks: number;
      };
      vm: null;
    };
    networking: {
      percentConnected: number;
    };
  };
  timestamp: string;
  duration: number;
};

const healthStatus = await client.health.health({
  tags: ["11111111111111111111111111111111LpoYY"],
});

console.log("Node healthy:", healthStatus.healthy);
console.log("C-Chain health:", healthStatus.checks.C);

function liveness(): Promise<LivenessReturnType>;

interface LivenessReturnType {
  checks: object;
  healthy: boolean;
}

const livenessStatus = await client.health.liveness();

if (livenessStatus.healthy) {
  console.log("Node is alive and responding");
}

function readiness(params: ReadinessParameters): Promise<ReadinessReturnType>;

interface ReadinessParameters {
  tags?: string[];
}

interface ReadinessReturnType {
  checks: {
    [key: string]: {
      message: {
        timestamp: string;
        duration: number;
        contiguousFailures: number;
        timeOfFirstFailure: string | null;
      };
      healthy: boolean;
    };
  };
  healthy: boolean;
}

const readinessStatus = await client.health.readiness({
  tags: ["11111111111111111111111111111111LpoYY"],
});

if (readinessStatus.healthy) {
  console.log("Node is ready to handle requests");
}

function getContainerByIndex(
  params: GetContainerByIndexParameters
): Promise<GetContainerByIndexReturnType>;

interface GetContainerByIndexParameters {
  index: number;
  encoding: "hex";
}

interface GetContainerByIndexReturnType {
  id: string;
  bytes: string;
  timestamp: string;
  encoding: "hex";
  index: string;
}

const container = await client.indexBlock.pChain.getContainerByIndex({
  index: 12345,
  encoding: "hex",
});

console.log("Container ID:", container.id);
console.log("Container bytes:", container.bytes);

function getContainerByID(
  params: GetContainerByIDParameters
): Promise<GetContainerByIDReturnType>;

interface GetContainerByIDParameters {
  id: string;
  encoding: "hex";
}

interface GetContainerByIDReturnType {
  id: string;
  bytes: string;
  timestamp: string;
  encoding: "hex";
  index: string;
}

const container = await client.indexBlock.cChain.getContainerByID({
  id: "0x123...",
  encoding: "hex",
});

console.log("Container index:", container.index);

function getContainerRange(
  params: GetContainerRangeParameters
): Promise<GetContainerRangeReturnType>;

interface GetContainerRangeParameters {
  startIndex: number;
  endIndex: number;
  encoding: "hex";
}

interface GetContainerRangeReturnType {
  containers: Array<{
    id: string;
    bytes: string;
    timestamp: string;
    encoding: "hex";
    index: string;
  }>;
}

const range = await client.indexBlock.xChain.getContainerRange({
  startIndex: 1000,
  endIndex: 1010,
  encoding: "hex",
});

console.log("Containers:", range.containers.length);

function getIndex(params: GetIndexParameters): Promise<GetIndexReturnType>;

interface GetIndexParameters {
  id: string;
  encoding: "hex";
}

interface GetIndexReturnType {
  index: string;
}

const result = await client.indexTx.xChain.getIndex({
  id: "0x123...",
  encoding: "hex",
});

console.log("Container index:", result.index);

function getLastAccepted(
  params: GetLastAcceptedParameters
): Promise<GetLastAcceptedReturnType>;

interface GetLastAcceptedParameters {
  encoding: "hex";
}

interface GetLastAcceptedReturnType {
  id: string;
  bytes: string;
  timestamp: string;
  encoding: "hex";
  index: string;
}

const lastAccepted = await client.indexBlock.pChain.getLastAccepted({
  encoding: "hex",
});

console.log("Last accepted container ID:", lastAccepted.id);
console.log("Last accepted index:", lastAccepted.index);

function isAccepted(
  params: IsAcceptedParameters
): Promise<IsAcceptedReturnType>;

interface IsAcceptedParameters {
  id: string;
  encoding: "hex";
}

interface IsAcceptedReturnType {
  isAccepted: boolean;
}

const result = await client.indexBlock.cChain.isAccepted({
  id: "0x123...",
  encoding: "hex",
});

if (result.isAccepted) {
  console.log("Container is accepted");
} else {
  console.log("Container is not accepted");
}

function getProposedHeight(): Promise<GetProposedHeightReturnType>;

interface GetProposedHeightReturnType {
  height: string;
}

const pChainHeight = await client.proposerVM.pChain.getProposedHeight();
console.log("P-Chain proposed height:", pChainHeight.height);

const xChainHeight = await client.proposerVM.xChain.getProposedHeight();
console.log("X-Chain proposed height:", xChainHeight.height);

const cChainHeight = await client.proposerVM.cChain.getProposedHeight();
console.log("C-Chain proposed height:", cChainHeight.height);

function getCurrentEpoch(): Promise<GetCurrentEpochReturnType>;

interface GetCurrentEpochReturnType {
  number: string;
  startTime: string;
  pChainHeight: string;
}

const epoch = await client.proposerVM.pChain.getCurrentEpoch();
console.log("Current epoch:", epoch.number);
console.log("Epoch start time:", epoch.startTime);
console.log("P-Chain height at epoch start:", epoch.pChainHeight);