Utilities

import {
  // AVAX conversions
  avaxToNanoAvax,
  nanoAvaxToAvax,
  avaxToWei,
  weiToAvax,
  weiToNanoAvax,
  nanoAvaxToWei,
  // CB58 encoding
  CB58ToHex,
  hexToCB58,
  // Transaction serialization
  getTxFromBytes,
  getUnsignedTxFromBytes,
  // UTXO operations
  getUtxoFromBytes,
  getUtxosForAddress,
  buildUtxoBytes,
} from "@avalanche-sdk/client/utils";

// Viem utilities are also available
import { hexToBytes, bytesToHex, isAddress } from "@avalanche-sdk/client/utils";

function avaxToNanoAvax(amount: number): bigint;

import { avaxToNanoAvax } from "@avalanche-sdk/client/utils";

const nanoAvax = avaxToNanoAvax(1.5);
console.log(nanoAvax); // 1500000000n

// Use in P-Chain transaction
const tx = await walletClient.pChain.prepareBaseTxn({
  outputs: [
    {
      addresses: ["P-avax1..."],
      amount: Number(nanoAvax),
    },
  ],
});

function nanoAvaxToAvax(amount: bigint): number;

import { nanoAvaxToAvax } from "@avalanche-sdk/client/utils";

const balance = await walletClient.pChain.getBalance({
  addresses: ["P-avax1..."],
});

const avax = nanoAvaxToAvax(BigInt(balance.balance || 0));
console.log(`Balance: ${avax} AVAX`);

function avaxToWei(amount: number): bigint;

import { avaxToWei } from "@avalanche-sdk/client/utils";

const wei = avaxToWei(1.5);
console.log(wei); // 1500000000000000000n

// Use in C-Chain transaction
const txHash = await walletClient.cChain.sendTransaction({
  to: "0x...",
  value: wei,
});

function weiToAvax(amount: bigint): bigint;

import { weiToAvax } from "@avalanche-sdk/client/utils";

const balance = await walletClient.cChain.getBalance({
  address: "0x...",
});

const avax = weiToAvax(balance);
console.log(`Balance: ${avax} AVAX`);

function weiToNanoAvax(amount: bigint): bigint;

import { weiToNanoAvax } from "@avalanche-sdk/client/utils";

const cChainBalance = await walletClient.cChain.getBalance({
  address: "0x...",
});

// Convert to nanoAVAX for P-Chain transfer
const nanoAvax = weiToNanoAvax(cChainBalance);

function nanoAvaxToWei(amount: bigint): bigint;

import { nanoAvaxToWei } from "@avalanche-sdk/client/utils";

const pChainBalance = await walletClient.pChain.getBalance({
  addresses: ["P-avax1..."],
});

// Convert to wei for C-Chain transfer
const wei = nanoAvaxToWei(BigInt(pChainBalance.balance || 0));

function CB58ToHex(cb58: string): Hex;

import { CB58ToHex } from "@avalanche-sdk/client/utils";

const txId = "mYxFK3CWs6iMFFaRx4wmVLDUtnktzm2o9Mhg9AG6JSzRijy5V";
const hex = CB58ToHex(txId);
console.log(hex); // 0x...

// Use with hex-based APIs
const tx = await client.pChain.getAtomicTx({ txID: hex });

function hexToCB58(hex: Hex): string;

import { hexToCB58 } from "@avalanche-sdk/client/utils";

const hex = "0x1234567890abcdef";
const cb58 = hexToCB58(hex);
console.log(cb58); // CB58 encoded string

function getTxFromBytes(
  txBytes: string,
  chainAlias: "P" | "X" | "C"
): [Common.Transaction, Credential[]];

import { getTxFromBytes } from "@avalanche-sdk/client/utils";

const txHex = "0x1234567890abcdef...";
const [tx, credentials] = getTxFromBytes(txHex, "P");

console.log("Transaction ID:", tx.getId().toString());
console.log("Signatures:", credentials.length);

function getUnsignedTxFromBytes(
  txBytes: string,
  chainAlias: "P" | "X" | "C"
): UnsignedTx;

import { getUnsignedTxFromBytes } from "@avalanche-sdk/client/utils";

const txHex = "0x1234567890abcdef...";
const unsignedTx = getUnsignedTxFromBytes(txHex, "P");

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

function getUtxoFromBytes(
  utxoBytesOrHex: string | Uint8Array,
  chainAlias: "P" | "X" | "C"
): Utxo;

import { getUtxoFromBytes } from "@avalanche-sdk/client/utils";

const utxoHex = "0x1234567890abcdef...";
const utxo = getUtxoFromBytes(utxoHex, "P");

console.log("UTXO ID:", utxo.utxoID);
console.log("Asset ID:", utxo.assetID);
console.log("Output:", utxo.output);

function getUtxosForAddress(
  client: AvalancheWalletCoreClient,
  params: {
    address: string;
    chainAlias: "P" | "X" | "C";
    sourceChain?: string;
  }
): Promise<Utxo[]>;

import { getUtxosForAddress } from "@avalanche-sdk/client/utils";
import { createAvalancheWalletClient } from "@avalanche-sdk/client";
import { avalanche } from "@avalanche-sdk/client/chains";

const walletClient = createAvalancheWalletClient({
  account: myAccount,
  chain: avalanche,
  transport: { type: "http" },
});

const utxos = await getUtxosForAddress(walletClient, {
  address: "P-avax1...",
  chainAlias: "P",
});

console.log(`Found ${utxos.length} UTXOs`);

function buildUtxoBytes(
  txHash: string,
  outputIndex: number,
  assetId: string,
  amount: string,
  addresses: string[],
  locktime: string,
  threshold: number
): `0x${string}`;

import { buildUtxoBytes } from "@avalanche-sdk/client/utils";

const utxoBytes = buildUtxoBytes(
  "mYxFK3CWs6iMFFaRx4wmVLDUtnktzm2o9Mhg9AG6JSzRijy5V",
  0,
  "U8iRqJoiJm8xZHAacmvYyZVwqQx6uDNtQeP3CQ6fcgQk3JqnK",
  "111947",
  ["P-fuji1nv6w7m6egkwhkcvz96ze3qmzyk5gt6csqz7ejq"],
  "0",
  1
);

console.log("UTXO bytes:", utxoBytes);

import {
  avaxToNanoAvax,
  nanoAvaxToAvax,
  avaxToWei,
  weiToAvax,
} from "@avalanche-sdk/client/utils";

// P-Chain: AVAX → nanoAVAX
const nanoAvax = avaxToNanoAvax(1.5);

// C-Chain: AVAX → wei
const wei = avaxToWei(1.5);

// Display: nanoAVAX → AVAX
const avax = nanoAvaxToAvax(nanoAvax);

import { CB58ToHex, hexToCB58 } from "@avalanche-sdk/client/utils";

// Convert CB58 to hex for API calls
const txId = "mYxFK3CWs6iMFFaRx4wmVLDUtnktzm2o9Mhg9AG6JSzRijy5V";
const hex = CB58ToHex(txId);

// Convert hex back to CB58 for display
const cb58 = hexToCB58(hex);

import { getTxFromBytes } from "@avalanche-sdk/client/utils";

const txHex = "0x...";
const [tx, credentials] = getTxFromBytes(txHex, "P");

// Access transaction details
const txId = tx.getId().toString();
const numSignatures = credentials.length;