P-Chain Methods

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

interface GetBalanceParameters {
  addresses: string[];
}

interface GetBalanceReturnType {
  balance: bigint;
  unlocked: bigint;
  lockedStakeable: bigint;
  lockedNotStakeable: 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.pChain.getBalance({
  addresses: ["P-custom18jma8ppw3nhx5r4ap8clazz0dps7rv5u9xde7p"],
});

console.log("Total balance:", balance.balance);
console.log("Unlocked:", balance.unlocked);
console.log("Locked stakeable:", balance.lockedStakeable);

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.pChain.getUTXOs({
  addresses: ["P-custom18jma8ppw3nhx5r4ap8clazz0dps7rv5u9xde7p"],
  limit: 100,
});

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

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

function getCurrentValidators(
  params: GetCurrentValidatorsParameters
): Promise<GetCurrentValidatorsReturnType>;

interface GetCurrentValidatorsParameters {
  subnetID?: string | Buffer;
  nodeIDs?: string[];
}

interface GetCurrentValidatorsReturnType {
  validators: Array<{
    accruedDelegateeReward: string;
    txID: string;
    startTime: string;
    endTime?: string;
    stakeAmount: string;
    nodeID: string;
    weight: string;
    validationRewardOwner?: {
      locktime: string;
      threshold: string;
      addresses: string[];
    };
    delegationRewardOwner?: {
      locktime: string;
      threshold: string;
      addresses: string[];
    };
    signer?: {
      publicKey: string;
      proofOfPosession: string;
    };
    delegatorCount?: string;
    delegatorWeight?: string;
    potentialReward?: string;
    delegationFee?: string;
    uptime?: string;
    connected?: boolean;
    delegators?: Array<{
      txID: string;
      startTime: string;
      endTime: string;
      stakeAmount: string;
      nodeID: string;
      rewardOwner: {
        locktime: string;
        threshold: string;
        addresses: string[];
      };
      potentialReward: string;
    }>;
  }>;
}

// Get all validators on Primary Network
const validators = await client.pChain.getCurrentValidators({});

console.log("Total validators:", validators.validators.length);

// Get validators for specific subnet
const subnetValidators = await client.pChain.getCurrentValidators({
  subnetID: "11111111111111111111111111111111LpoYY",
});

// Get specific validators
const specificValidators = await client.pChain.getCurrentValidators({
  subnetID: "11111111111111111111111111111111LpoYY",
  nodeIDs: ["NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg"],
});

function getValidatorsAt(
  params: GetValidatorsAtParameters
): Promise<GetValidatorsAtReturnType>;

interface GetValidatorsAtParameters {
  height: number;
  subnetID?: string;
}

interface GetValidatorsAtReturnType {
  validators: Record<string, number>;
}

const validators = await client.pChain.getValidatorsAt({
  height: 1000001,
  subnetID: "11111111111111111111111111111111LpoYY",
});

console.log("Validators at height:", validators.validators);

function getAllValidatorsAt(
  params: GetAllValidatorsAtParameters
): Promise<GetAllValidatorsAtReturnType>;

interface GetAllValidatorsAtParameters {
  height: number | "proposed";
}

interface GetAllValidatorsAtReturnType {
  validatorSets: Record<
    string,
    {
      validators: Array<{
        publicKey: string;
        weight: string;
        nodeIDs: string[];
      }>;
      totalWeight: string;
    }
  >;
}

// Get all validators at specific height
const validators = await client.pChain.getAllValidatorsAt({
  height: 1000001,
});

// Get validators at proposed height
const proposedValidators = await client.pChain.getAllValidatorsAt({
  height: "proposed",
});

console.log("Subnet IDs:", Object.keys(validators.validatorSets));
Object.entries(validators.validatorSets).forEach(([subnetID, set]) => {
  console.log(`Subnet ${subnetID}:`);
  console.log(`  Total weight: ${set.totalWeight}`);
  console.log(`  Validators: ${set.validators.length}`);
});

function sampleValidators(
  params: SampleValidatorsParameters
): Promise<SampleValidatorsReturnType>;

interface SampleValidatorsParameters {
  samplingSize: number;
  subnetID?: string;
  pChainHeight?: number;
}

interface SampleValidatorsReturnType {
  validators: string[];
}

const sampled = await client.pChain.sampleValidators({
  samplingSize: 5,
  subnetID: "11111111111111111111111111111111LpoYY",
});

console.log("Sampled validators:", sampled.validators);

function getHeight(): Promise<GetHeightReturnType>;

interface GetHeightReturnType {
  height: number;
}

const height = await client.pChain.getHeight();
console.log("Current P-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.pChain.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.pChain.getBlock({
  blockId: "d7WYmb8VeZNHsny3EJCwMm6QA37s1EHwMxw1Y71V3FqPZ5EFG",
  encoding: "hex",
});

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

function getStake(params: GetStakeParameters): Promise<GetStakeReturnType>;

interface GetStakeParameters {
  addresses: string[];
  subnetID: string;
}

interface GetStakeReturnType {
  stakeAmount: bigint;
}

const stake = await client.pChain.getStake({
  addresses: ["P-custom18jma8ppw3nhx5r4ap8clazz0dps7rv5u9xde7p"],
  subnetID: "11111111111111111111111111111111LpoYY",
});

console.log("Stake amount:", stake.stakeAmount);

function getTotalStake(
  params: GetTotalStakeParameters
): Promise<GetTotalStakeReturnType>;

interface GetTotalStakeParameters {
  subnetID: string;
}

interface GetTotalStakeReturnType {
  stake: bigint;
  weight: bigint;
}

const totalStake = await client.pChain.getTotalStake({
  subnetID: "11111111111111111111111111111111LpoYY",
});

console.log("Total stake:", totalStake.stake);
console.log("Total weight:", totalStake.weight);

function getMinStake(
  params: GetMinStakeParameters
): Promise<GetMinStakeReturnType>;

interface GetMinStakeParameters {
  subnetID: string;
}

interface GetMinStakeReturnType {
  minValidatorStake: bigint;
  minDelegatorStake: bigint;
}

const minStake = await client.pChain.getMinStake({
  subnetID: "11111111111111111111111111111111LpoYY",
});

console.log("Min validator stake:", minStake.minValidatorStake);
console.log("Min delegator stake:", minStake.minDelegatorStake);

function getSubnet(params: GetSubnetParameters): Promise<GetSubnetReturnType>;

interface GetSubnetParameters {
  subnetID: string;
}

interface GetSubnetReturnType {
  isPermissioned: boolean;
  controlKeys: string[];
  threshold: string;
  locktime: string;
  subnetTransformationTxID: string;
  conversionID: string;
  managerChainID: string;
  managerAddress: string | null;
}

const subnet = await client.pChain.getSubnet({
  subnetID: "11111111111111111111111111111111LpoYY",
});

console.log("Is permissioned:", subnet.isPermissioned);
console.log("Control keys:", subnet.controlKeys);
console.log("Threshold:", subnet.threshold);

function getSubnets(
  params: GetSubnetsParameters
): Promise<GetSubnetsReturnType>;

interface GetSubnetsParameters {
  ids: string[];
}

interface GetSubnetsReturnType {
  subnets: {
    id: string;
    controlKeys: string[];
    threshold: string;
  }[];
}

const subnets = await client.pChain.getSubnets({
  ids: [
    "11111111111111111111111111111111LpoYY",
    "SubnetID-11111111111111111111111111111111LpoYY",
  ],
});

console.log("Number of subnets:", subnets.subnets.length);
subnets.subnets.forEach((subnet) => {
  console.log("Subnet ID:", subnet.id);
  console.log("Control keys:", subnet.controlKeys);
});

function getStakingAssetID(
  params: GetStakingAssetIDParameters
): Promise<GetStakingAssetIDReturnType>;

interface GetStakingAssetIDParameters {
  subnetID: string;
}

interface GetStakingAssetIDReturnType {
  assetID: string;
}

const stakingAsset = await client.pChain.getStakingAssetID({
  subnetID: "11111111111111111111111111111111LpoYY",
});

console.log("Staking asset ID:", stakingAsset.assetID);

function getBlockchains(): Promise<GetBlockchainsReturnType>;

interface GetBlockchainsReturnType {
  blockchains: {
    id: string;
    name: string;
    subnetID: string;
    vmID: string;
  }[];
}

const blockchains = await client.pChain.getBlockchains();

console.log("Number of blockchains:", blockchains.blockchains.length);

blockchains.blockchains.forEach((blockchain) => {
  console.log("Blockchain:", blockchain.name);
  console.log("  ID:", blockchain.id);
  console.log("  Subnet ID:", blockchain.subnetID);
  console.log("  VM ID:", blockchain.vmID);
});

function getBlockchainStatus(
  params: GetBlockchainStatusParameters
): Promise<GetBlockchainStatusReturnType>;

interface GetBlockchainStatusParameters {
  blockchainId: string;
}

interface GetBlockchainStatusReturnType {
  status: "Validating" | "Created" | "Preferred" | "Syncing" | "Unknown";
}

const status = await client.pChain.getBlockchainStatus({
  blockchainId: "11111111111111111111111111111111LpoYY",
});

console.log("Blockchain status:", status.status);

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.pChain.getTx({
  txID: "11111111111111111111111111111111LpoYY",
  encoding: "hex",
});

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

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

interface GetTxStatusParameters {
  txID: string;
}

interface GetTxStatusReturnType {
  status: "Committed" | "Pending" | "Dropped" | "Unknown";
  reason?: string;
}

const txStatus = await client.pChain.getTxStatus({
  txID: "11111111111111111111111111111111LpoYY",
});

console.log("Transaction status:", txStatus.status);
if (txStatus.reason) {
  console.log("Reason:", txStatus.reason);
}

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

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

interface IssueTxReturnType {
  txID: string;
}

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

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

function getProposedHeight(): Promise<GetProposedHeightReturnType>;

interface GetProposedHeightReturnType {
  height: number;
}

const proposedHeight = await client.pChain.getProposedHeight();
console.log("Proposed height:", proposedHeight.height);

function getTimestamp(): Promise<GetTimestampReturnType>;

interface GetTimestampReturnType {
  timestamp: string;
}

const timestamp = await client.pChain.getTimestamp();
console.log("Current timestamp:", timestamp.timestamp);

function getFeeConfig(): Promise<GetFeeConfigReturnType>;

interface GetFeeConfigReturnType {
  weights: [
    bandwidth: number,
    dbRead: number,
    dbWrite: number,
    compute: number,
  ];
  maxCapacity: bigint;
  maxPerSecond: bigint;
  targetPerSecond: bigint;
  minPrice: bigint;
  excessConversionConstant: bigint;
}

const feeConfig = await client.pChain.getFeeConfig();

console.log("Fee weights:", feeConfig.weights);
console.log("Max capacity:", feeConfig.maxCapacity);
console.log("Target per second:", feeConfig.targetPerSecond);
console.log("Min price:", feeConfig.minPrice);

function getFeeState(): Promise<GetFeeStateReturnType>;

interface GetFeeStateReturnType {
  capacity: bigint;
  excess: bigint;
  price: bigint;
  timestamp: string;
}

const feeState = await client.pChain.getFeeState();

console.log("Fee capacity:", feeState.capacity);
console.log("Fee excess:", feeState.excess);
console.log("Fee price:", feeState.price);
console.log("Timestamp:", feeState.timestamp);

function getCurrentSupply(
  params?: GetCurrentSupplyParameters
): Promise<GetCurrentSupplyReturnType>;

interface GetCurrentSupplyParameters {
  subnetId?: string;
}

interface GetCurrentSupplyReturnType {
  supply: bigint;
}

// Get Primary Network supply
const supply = await client.pChain.getCurrentSupply();
console.log("Primary Network supply:", supply.supply);

// Get subnet-specific supply
const subnetSupply = await client.pChain.getCurrentSupply({
  subnetId: "11111111111111111111111111111111LpoYY",
});
console.log("Subnet supply:", subnetSupply.supply);

function getRewardUTXOs(
  params: GetRewardUTXOsParameters
): Promise<GetRewardUTXOsReturnType>;

interface GetRewardUTXOsParameters {
  txID: string;
  encoding?: "hex";
}

interface GetRewardUTXOsReturnType {
  numFetched: number;
  utxos: string[];
  encoding: "hex";
}

const rewardUTXOs = await client.pChain.getRewardUTXOs({
  txID: "11111111111111111111111111111111LpoYY",
  encoding: "hex",
});

console.log("Reward UTXOs fetched:", rewardUTXOs.numFetched);
console.log("UTXOs:", rewardUTXOs.utxos);

function getL1Validator(
  params: GetL1ValidatorParameters
): Promise<GetL1ValidatorReturnType>;

interface GetL1ValidatorParameters {
  validationID: string;
}

interface GetL1ValidatorReturnType {
  subnetID: string;
  nodeID: string;
  publicKey: string;
  remainingBalanceOwner: {
    addresses: string[];
    locktime: string;
    threshold: string;
  };
  deactivationOwner: {
    addresses: string[];
    locktime: string;
    threshold: string;
  };
  startTime: bigint;
  weight: bigint;
  minNonce?: bigint;
  balance?: bigint;
  height?: bigint;
}

const validator = await client.pChain.getL1Validator({
  validationID: "11111111111111111111111111111111LpoYY",
});

console.log("Subnet ID:", validator.subnetID);
console.log("Node ID:", validator.nodeID);
console.log("Weight:", validator.weight);
console.log("Start time:", validator.startTime);

function validatedBy(
  params: ValidatedByParameters
): Promise<ValidatedByReturnType>;

interface ValidatedByParameters {
  blockchainID: string;
}

interface ValidatedByReturnType {
  subnetID: string;
}

const validatedBy = await client.pChain.validatedBy({
  blockchainID: "11111111111111111111111111111111LpoYY",
});

console.log("Validated by subnet:", validatedBy.subnetID);

function validates(params: ValidatesParameters): Promise<ValidatesReturnType>;

interface ValidatesParameters {
  subnetID: string;
}

interface ValidatesReturnType {
  blockchainIDs: string[];
}

const validates = await client.pChain.validates({
  subnetID: "11111111111111111111111111111111LpoYY",
});

console.log("Number of blockchains:", validates.blockchainIDs.length);
validates.blockchainIDs.forEach((blockchainID) => {
  console.log("Blockchain ID:", blockchainID);
});