Wallet Methods

function send(params: SendParameters): Promise<SendReturnType>;

interface SendParameters {
  account?: AvalancheAccount;
  amount: bigint;
  to: Address | XPAddress;
  from?: Address | XPAddress;
  sourceChain?: "P" | "C";
  destinationChain?: "P" | "C";
  token?: "AVAX";
  context?: Context;
}

interface SendReturnType {
  txHashes: TransactionDetails[];
}

interface TransactionDetails {
  txHash: string;
  chainAlias: "P" | "C";
}

import { createAvalancheWalletClient } from "@avalanche-sdk/client";
import { privateKeyToAvalancheAccount } from "@avalanche-sdk/client/accounts";
import { avalanche } from "@avalanche-sdk/client/chains";
import { avaxToWei, avaxToNanoAvax } from "@avalanche-sdk/client/utils";

const account = privateKeyToAvalancheAccount("0x...");

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

// Send AVAX on C-Chain
const result = await walletClient.send({
  to: "0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6",
  amount: avaxToWei(0.001),
  destinationChain: "C",
});

console.log("Transaction hash:", result.txHashes[0].txHash);

// Send AVAX from C-Chain to P-Chain
const crossChainResult = await walletClient.send({
  to: "P-avax1example...",
  amount: avaxToWei(1),
  sourceChain: "C",
  destinationChain: "P",
});

console.log("Transfer transactions:", crossChainResult.txHashes);

function getAccountPubKey(): Promise<GetAccountPubKeyReturnType>;

interface GetAccountPubKeyReturnType {
  evm: string;
  xp: string;
}

const pubKeys = await walletClient.getAccountPubKey();

console.log("EVM public key:", pubKeys.evm);
console.log("XP public key:", pubKeys.xp);

function waitForTxn(params: WaitForTxnParameters): Promise<void>;

interface WaitForTxnParameters {
  txHash: string;
  chainAlias: "X" | "P" | "C";
  sleepTime?: number;
  maxRetries?: number;
}

const txHash = "0x...";

try {
  await walletClient.waitForTxn({
    txHash,
    chainAlias: "C",
    sleepTime: 500, // Wait 500ms between checks
    maxRetries: 20, // Check up to 20 times
  });

  console.log("Transaction confirmed!");
} catch (error) {
  console.error("Transaction failed:", error);
}

function sendXPTransaction(
  params: SendXPTransactionParameters
): Promise<SendXPTransactionReturnType>;

interface SendXPTransactionParameters {
  account?: AvalancheAccount | Address;
  tx: string | UnsignedTx;
  chainAlias: "X" | "P" | "C";
  externalIndices?: number[];
  internalIndices?: number[];
  utxoIds?: string[];
  feeTolerance?: number;
  subnetAuth?: number[];
  subnetOwners?: PChainOwner;
  disableOwners?: PChainOwner;
  disableAuth?: number[];
}

interface SendXPTransactionReturnType {
  txHash: string;
  chainAlias: "X" | "P" | "C";
}

// This is typically used with prepare methods from chain-specific wallets
const unsignedTx = await walletClient.pChain.prepareBaseTxn({
  outputs: [
    {
      addresses: ["P-fuji19fc97zn3mzmwr827j4d3n45refkksgms4y2yzz"],
      amount: avaxToNanoAvax(1),
    },
  ],
});

const signedTx = await walletClient.signXPTransaction({
  tx: unsignedTx.tx,
  chainAlias: "P",
});

const { txHash } = await walletClient.sendXPTransaction({
  tx: signedTx.signedTxHex,
  chainAlias: "P",
});

console.log("Transaction hash:", txHash);

function signXPTransaction(
  params: SignXPTransactionParameters
): Promise<SignXPTransactionReturnType>;

interface SignXPTransactionParameters {
  account?: AvalancheAccount | Address;
  tx?: string | UnsignedTx;
  signedTxHex?: string;
  chainAlias: "X" | "P" | "C";
  utxoIds?: string[];
  subnetAuth?: number[];
  subnetOwners?: PChainOwner;
  disableOwners?: PChainOwner;
  disableAuth?: number[];
  context?: Context;
}

interface Signatures {
  signature: string;
  sigIndices: number[];
}

interface SignXPTransactionReturnType {
  signedTxHex: string;
  signatures: Signatures[];
  chainAlias: "X" | "P" | "C";
  subnetAuth?: number[];
  subnetOwners?: PChainOwner;
  disableOwners?: PChainOwner;
  disableAuth?: number[];
}

const unsignedTx = await walletClient.pChain.prepareBaseTxn({
  outputs: [
    {
      addresses: ["P-fuji19fc97zn3mzmwr827j4d3n45refkksgms4y2yzz"],
      amount: avaxToNanoAvax(0.1),
    },
  ],
});

const signedTx = await walletClient.signXPTransaction({
  tx: unsignedTx.tx,
  chainAlias: "P",
});

// Now send the signed transaction
const { txHash } = await walletClient.sendXPTransaction({
  tx: signedTx.signedTxHex,
  chainAlias: "P",
});

console.log("Transaction hash:", txHash);

function signXPMessage(
  params: SignXPMessageParameters
): Promise<SignXPMessageReturnType>;

interface SignXPMessageParameters {
  account?: AvalancheAccount | Address;
  message: string;
  accountIndex?: number;
}

interface SignXPMessageReturnType {
  signature: string;
}

const { signature } = await walletClient.signXPMessage({
  message: "Hello Avalanche",
});

console.log("Signature:", signature);

// Send transaction
const hash = await walletClient.sendTransaction({
  to: "0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6",
  value: parseEther("0.001"),
});

// Sign message
const signature = await walletClient.signMessage({
  message: "Hello World",
});

// Sign typed data (EIP-712)
const typedSignature = await walletClient.signTypedData({
  domain: { ... },
  types: { ... },
  primaryType: "Message",
  message: { ... },
});

// Prepare base transaction
const baseTx = await walletClient.pChain.prepareBaseTxn({
  outputs: [
    {
      addresses: ["P-fuji19fc97zn3mzmwr827j4d3n45refkksgms4y2yzz"],
      amount: avaxToNanoAvax(1),
    },
  ],
});

// Prepare export transaction
const exportTx = await walletClient.pChain.prepareExportTxn({
  destinationChain: "C",
  exportedOutputs: [
    {
      addresses: ["0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6"],
      amount: avaxToNanoAvax(1),
    },
  ],
});

// Prepare import transaction
const importTx = await walletClient.pChain.prepareImportTxn({
  sourceChain: "C",
  importedOutput: {
    addresses: ["P-fuji19fc97zn3mzmwr827j4d3n45refkksgms4y2yzz"],
  },
});

// Prepare base transaction
const baseTx = await walletClient.xChain.prepareBaseTxn({
  outputs: [
    {
      addresses: ["X-fuji19fc97zn3mzmwr827j4d3n45refkksgms4y2yzz"],
      amount: avaxToNanoAvax(1),
    },
  ],
});

// Prepare export transaction
const exportTx = await walletClient.cChain.prepareExportTxn({
  destinationChain: "P",
  fromAddress: account.getEVMAddress(),
  exportedOutput: {
    addresses: [account.getXPAddress("P")],
    amount: avaxToNanoAvax(1),
  },
});

// Prepare import transaction
const importTx = await walletClient.cChain.prepareImportTxn({
  sourceChain: "P",
  toAddress: account.getEVMAddress(),
});