@avalabs/core-wallets-sdk 2.8.0-alpha.197

package/dist/index.d.ts

@@ -0,0 +1,1794 @@
+import { Transaction } from '@ledgerhq/hw-app-btc/lib/types';
+import * as bitcoinjs_lib from 'bitcoinjs-lib';
+import { Network, Psbt, ECPairInterface, Transaction as Transaction$1 } from 'bitcoinjs-lib';
+export { networks as BtcNetworks } from 'bitcoinjs-lib';
+import { WalletPolicy, PsbtV2 } from 'ledger-bitcoin';
+import * as ethers from 'ethers';
+import { Provider, VoidSigner, HDNodeWallet, TransactionResponse, JsonRpcProvider as JsonRpcProvider$1, FetchRequest, Network as Network$1, Contract, AbstractSigner, BytesLike, TransactionRequest, TypedDataDomain, TypedDataField } from 'ethers';
+import Transport from '@ledgerhq/hw-transport';
+import Eth from '@ledgerhq/hw-app-eth';
+import * as _avalabs_avalanchejs from '@avalabs/avalanchejs';
+import { VM, Common, OutputOwners, TransferableOutput, pvmSerial, Context, avm, pvm, evm, avaxSerial, utils, UnsignedTx, EVMUnsignedTx, Utxo, Credential, Signature } from '@avalabs/avalanchejs';
+import * as _avalabs_avalanchejs_dist_vms_common from '@avalabs/avalanchejs/dist/vms/common';
+import { Bip32Path } from 'bip32-path';
+import AppZondax, { ResponseBase } from '@avalabs/hw-app-avalanche';
+import { BIP32Interface } from 'bip32';
+import { Utxo as Utxo$1, PChainUtxo } from '@avalabs/glacier-sdk';
+import { WalletAbstract as WalletAbstract$1 } from 'Avalanche/wallets';
+
+/**
+ * Custom Bitcoin UTXO interface.
+ */
+interface BitcoinInputUTXO {
+    txHash: string;
+    txHex?: string;
+    index: number;
+    value: number;
+    script: string;
+    blockHeight: number;
+    confirmations: number;
+    confirmedTime?: string;
+}
+interface BitcoinInputUTXOWithOptionalScript extends Omit<BitcoinInputUTXO, 'script'> {
+    script?: string;
+}
+/**
+ * Used for defining outputs when creating a transaction.
+ */
+interface BitcoinOutputUTXO {
+    address: string;
+    value: number;
+}
+/**
+ * Ledger needs UTXOs organized like this when signing.
+ */
+type BitcoinLedgerInputUTXO = [
+    tx: Transaction,
+    outputIndex: number,
+    script: string | null | undefined,
+    sequence: number | null | undefined
+];
+/**
+ * An interface to simplify historic BTC transactions.
+ */
+interface BitcoinHistoryTx {
+    hash: string;
+    isSender: boolean;
+    addresses: string[];
+    fee: number;
+    block: number;
+    amount: number;
+    confirmations: number;
+    containsMultisig: boolean;
+    receivedTime: number;
+    confirmedTime?: number;
+}
+interface BitcoinTx {
+    hash: string;
+    fees: number;
+    block: number;
+    amount: number;
+    confirmations: number;
+    blockTime: number;
+    addresses: string[];
+    inputs: {
+        txid: string;
+        vout: number;
+        sequence: number;
+        n: number;
+        addresses: string[];
+        isAddress: boolean;
+        value: number;
+    }[];
+    outputs: {
+        addresses: string[];
+        value: number;
+        n: number;
+        spent: boolean;
+        hex: string;
+        isAddress: boolean;
+    }[];
+}
+
+declare abstract class BitcoinProviderAbstract {
+    /**
+     * Returns the UTXOs owned by the given address.
+     * @param address
+     */
+    abstract getUTXOs(address: string, withScripts: boolean): Promise<{
+        confirmed: BitcoinInputUTXOWithOptionalScript[];
+        unconfirmed: BitcoinInputUTXOWithOptionalScript[];
+    }>;
+    /**
+     * Returns the connected network.
+     */
+    abstract getNetwork(): Network;
+    /**
+     * Get the current chain height.
+     */
+    abstract getChainHeight(): Promise<number>;
+    /**
+     * Returns the available balance for the user in satoshis.
+     */
+    abstract getBalances(address: string): Promise<{
+        available: bigint;
+        pending: bigint;
+        final: bigint;
+    }>;
+    /**
+     * Returns available (confirmed) UTXOs and their total balance for the given address.
+     * @address Address to get UTXOs of.
+     */
+    getUtxoBalance(address: string, withScripts?: boolean): Promise<{
+        balance: number;
+        balanceUnconfirmed: number;
+        utxos: BitcoinInputUTXOWithOptionalScript[];
+        utxosUnconfirmed: BitcoinInputUTXOWithOptionalScript[];
+    }>;
+    /**
+     * Given a transaction hash, return the base information of the transaction
+     */
+    abstract getTransaction(hash: string): Promise<BitcoinTx>;
+    /**
+     * Given a transaction hash, return the whole transaction in hex format.
+     * @param txHash
+     */
+    abstract getTxHex(txHash: string): Promise<string>;
+    /**
+     * Issues the given transaction to the bitcoin network
+     * @param tx
+     */
+    abstract issueRawTx(tx: string): Promise<string>;
+    /**
+     * Returns the suggested fee rate in satoshis per byte.
+     */
+    abstract getFeeRates(): Promise<{
+        high: number;
+        medium: number;
+        low: number;
+    }>;
+}
+
+declare class BitcoinProvider extends BitcoinProviderAbstract {
+    #private;
+    private readonly isMainnet;
+    private readonly extraParams?;
+    constructor(isMainnet?: boolean, apiKey?: string, explorerUrl?: string, nodeUrl?: string, extraParams?: Record<string, string> | undefined);
+    getTxHex(txHash: string): Promise<string>;
+    getUTXOs(address: string, withScripts?: boolean): Promise<{
+        confirmed: BitcoinInputUTXOWithOptionalScript[];
+        unconfirmed: BitcoinInputUTXOWithOptionalScript[];
+    }>;
+    getScriptsForUtxos(utxos: BitcoinInputUTXOWithOptionalScript[]): Promise<BitcoinInputUTXO[]>;
+    private _parseUtxo;
+    getBalances(address: string): Promise<{
+        available: bigint;
+        pending: bigint;
+        final: bigint;
+    }>;
+    getChainHeight(): Promise<number>;
+    getFeeRates(): Promise<{
+        low: number;
+        medium: number;
+        high: number;
+    }>;
+    getNetwork(): Network;
+    issueRawTx(tx: string): Promise<string>;
+    getTransaction(hash: string): Promise<BitcoinTx>;
+    /**
+     * Returns the last 25 transactions
+     */
+    getTxHistory(address: string): Promise<BitcoinHistoryTx[]>;
+    waitForTx(txHash: string, { maxAttempts, attempt, pollInterval, }?: {
+        maxAttempts?: number;
+        attempt?: number;
+        pollInterval?: number;
+    }): Promise<BitcoinTx>;
+}
+
+declare function addEncodedSigToPsbt(sig: Buffer, pubkey: Buffer, psbt: Psbt, index: number): void;
+
+/**
+ * Create an unsigned transaction.
+ * @param inputs The input UTXOs for the transaction.
+ * @param outputs The output UTXOs for the transaction.
+ * @param provider The provider for the tx network.
+ */
+declare function createPsbt(inputs: BitcoinInputUTXO[], outputs: BitcoinOutputUTXO[], network: Network): Psbt;
+
+/**
+ * Create an unsigned bitcoin transfer transaction.
+ * @param to Destination address.
+ * @param changeAddress Change address.
+ * @param amount Amount to send.
+ * @param feeRate Satoshis per byte.
+ * @param sourceUtxos UTXOs to construct the transaction from.
+ * @param network The network the transaction will be on.
+ */
+declare function createTransferTx(to: string, changeAddress: string, amount: number, feeRate: number, sourceUtxos: BitcoinInputUTXO[], network: Network): {
+    fee: number;
+    inputs?: BitcoinInputUTXO[];
+    outputs?: BitcoinOutputUTXO[];
+    psbt?: Psbt;
+};
+
+/**
+ * Format the given address for the given network
+ * @param address Bech32 address to format
+ * @param network Network the new bech32 address will belong to
+ */
+declare function formatAddressForNetworkBech32(address: string, network: Network): string;
+
+/**
+ * Return the bech32 address of a given public key.
+ * @param pubkey
+ * @param network
+ */
+declare function getBech32Address(pubkey: Buffer, network: Network): string;
+
+/**
+ * Return the Bech32 address of the given address index from an xpub.
+ * @param xpub The extended public key of `m/44'/60'/0'`
+ * @param accountIndex The target address index.
+ * @param network Which network should the address be on.
+ */
+declare function getBech32AddressFromXPub(xpub: string, accountIndex: number, network: Network): string;
+
+/**
+ * Calculate the maximum amount that can be sent in satoshis using the given UTXO set and parameters.
+ * @param ins UTXOs that can be consumed.
+ * @param to Destination address.
+ * @param changeAddress Change address.
+ * @param feeRate Fee rate in satoshis per byte.
+ * @returns Maximum transferable amount in satoshis.
+ */
+declare function getMaxTransferAmount(ins: BitcoinInputUTXOWithOptionalScript[], to: string, changeAddress: string, feeRate: number): number;
+
+/**
+ * Uses coinselect to select the input and output utxos for the given information.
+ * Returns undefined if the transaction can not be completed.
+ * @param to Destination address.
+ * @param changeAddress Change address.
+ * @param amount Amount to send in satoshis.
+ * @param feeRate Satoshis per byte.
+ * @param sourceUtxos UTXOs to pick from to construct the transaction.
+ */
+declare function selectUtxos<InputUtxo extends BitcoinInputUTXO | BitcoinInputUTXOWithOptionalScript = BitcoinInputUTXO>(to: string, changeAddress: string, amount: number, feeRate: number, sourceUtxos: InputUtxo[]): {
+    fee: any;
+    inputs?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: InputUtxo[];
+    outputs: BitcoinOutputUTXO[];
+    fee: any;
+};
+
+declare function createWalletPolicy(masterFingerprint: string, accountIndex: number, accountXPUB: string, policyName: string): WalletPolicy;
+
+/**
+ * Used with the new BTC Ledger app.
+ */
+declare function createPSBTV2(ins: BitcoinInputUTXO[], outs: BitcoinOutputUTXO[], network: Network, masterFingerprint: Buffer, signerPubkey: Buffer, signerPath: string): PsbtV2;
+
+/**
+ * Convert the given PSBTV2 object to bitcoinjs PSBT object. This is not a full feature
+ * conversion and only focuses on P2WPKH input conversion, which are the input types supported by
+ * the core wallets.
+ * @param psbt2
+ * @param network
+ * @param signerPub
+ * @param signerPath
+ */
+declare function psbt2ToPsbt0(psbt2: PsbtV2, network: Network, signerPub: Buffer, signerPath: string): Psbt;
+
+/**
+ * Create an unsigned bitcoin transfer transaction.
+ * @param to Destination address.
+ * @param changeAddress Change address.
+ * @param amount Amount to send.
+ * @param feeRate Satoshis per byte.
+ * @param sourceUtxos UTXOs to construct the transaction from.
+ */
+declare function getTransferTxDetails<InputUtxo extends BitcoinInputUTXO | BitcoinInputUTXOWithOptionalScript = BitcoinInputUTXO>(to: string, changeAddress: string, amount: number, feeRate: number, sourceUtxos: InputUtxo[]): {
+    fee: number;
+    inputs?: InputUtxo[];
+    outputs?: BitcoinOutputUTXO[];
+};
+
+declare abstract class BitcoinWalletAbstract {
+    protected pubkey: Buffer;
+    protected provider: BitcoinProviderAbstract;
+    ecPair: ECPairInterface;
+    abstract signTx(ins: BitcoinInputUTXO[], outs: BitcoinOutputUTXO[]): Promise<Transaction$1>;
+    /**
+     * Return legacy P2PKH address.
+     */
+    getAddressP2PKH(): string | undefined;
+    /**
+     * Get the Bech32 address.
+     * @link https://allprivatekeys.com/bitcoin-address-format
+     */
+    getAddressBech32(): string;
+    protected constructor(pubkey: Buffer, provider: BitcoinProviderAbstract);
+    /**
+     * Returns the UTXOs owned by this address
+     */
+    getUTXOs(): Promise<{
+        confirmed: BitcoinInputUTXOWithOptionalScript[];
+        unconfirmed: BitcoinInputUTXOWithOptionalScript[];
+    }>;
+    /**
+     * Returns the available balance in satoshis.
+     * @remarks Returned balances might not match the sum of available UTXOs if the wallet has pending transactions.
+     * Use `getUTXOBalance` to get the balance from available UTXOs.
+     */
+    getBalances(): Promise<{
+        available: bigint;
+        pending: bigint;
+        final: bigint;
+    }>;
+    /**
+     * Returns available UTXOs and their total balance.
+     */
+    getUtxoBalance(): Promise<{
+        balance: number;
+        balanceUnconfirmed: number;
+        utxos: BitcoinInputUTXOWithOptionalScript[];
+        utxosUnconfirmed: BitcoinInputUTXOWithOptionalScript[];
+    }>;
+    /**
+     * Connects the wallet to the given provider.
+     * @param provider
+     */
+    connect(provider: BitcoinProviderAbstract): void;
+    /**
+     * Returns the current connected provider.
+     */
+    getProvider(): BitcoinProviderAbstract;
+    getPublicKey(): Buffer;
+    /**
+     * Create an unsigned transaction. Change will be returned to this wallet.
+     * @param to
+     * @param amount
+     * @param feeRate
+     * @param sourceUTXOs
+     */
+    createTransferTx(to: string, amount: number, feeRate: number, sourceUTXOs: BitcoinInputUTXO[]): {
+        fee: number;
+        inputs?: BitcoinInputUTXO[] | undefined;
+        outputs?: BitcoinOutputUTXO[] | undefined;
+        psbt?: bitcoinjs_lib.Psbt | undefined;
+    };
+}
+
+/**
+ * Returns hw-app-eth for the given transport
+ * @param transport
+ */
+declare function getAppEth(transport: Transport): Eth;
+
+/**
+ * Returns a readonly, void signer class from ethers.
+ * @param address
+ * @param provider
+ */
+declare function getVoidSigner(address: string, provider?: Provider): VoidSigner;
+
+declare const ETH_COIN_PATH = "m/44'/60'";
+declare const ETH_ACCOUNT_PATH: string;
+declare enum DerivationPath {
+    BIP44 = "bip44",
+    LedgerLive = "ledger_live"
+}
+
+/**
+ * Returns a wallet instance given a mnemonic and the account index.
+ * @remarks Uses the fixed
+ * @param mnemonic
+ * @param accountIndex
+ * @param pathSpec Either BIP44 or Ledger Live
+ */
+declare function getWalletFromMnemonic(mnemonic: string, accountIndex: number, pathSpec: DerivationPath): HDNodeWallet;
+
+declare const onBalanceChange: (walletAddresses: string[], erc20Addresses: string[], provider: Provider, callback: (txn: TransactionResponse, eventData: {
+    type: 'native' | 'erc20';
+    contractAddress?: string;
+}) => void) => Promise<{
+    unsubscribe: () => Promise<Provider>;
+}>;
+declare const isNativeTxn: (txn: TransactionResponse, walletAddressSet: Set<string>) => boolean;
+declare const isERC20Transfer: (txn: TransactionResponse, walletAddressSet: Set<string>) => boolean;
+
+type PendingBatch = null | Array<{
+    request: {
+        method: string;
+        params: Array<any>;
+        id: number;
+        jsonrpc: '2.0';
+    };
+    resolve: (result: any) => void;
+    reject: (error: Error) => void;
+}>;
+declare class JsonRpcBatchInternal extends JsonRpcProvider$1 {
+    #private;
+    private url?;
+    constructor(config: {
+        maxCalls: number;
+        multiContractAddress?: string;
+    } | number, urlOrFetchRequest?: string | FetchRequest, network?: Network$1);
+    _pendingBatchAggregator: NodeJS.Timer | null;
+    _pendingBatch: PendingBatch;
+    _maxCalls: number;
+    _parentProvider?: JsonRpcProvider$1;
+    _multicallContract?: Contract;
+    send(method: string, params: Array<any>): Promise<any>;
+    flush: () => void;
+    batchSend: (batch: PendingBatch) => Promise<any>;
+    batchSendMultiCall: (batch: PendingBatch) => Promise<any>;
+}
+
+/**
+ * Returns the public key for an address given the account extended pubic key.
+ * @param xpriv Extended private key for m/44'/60'/0'
+ * @param accountIndex Index of the address
+ * @returns Public key for m/44'/60'/0'/0/n where `n` is the address index
+ */
+declare function getAddressPrivateKeyFromXPriv(xpriv: string, accountIndex: number): Buffer;
+
+/**
+ * Returns the public key for an address given the account extended pubic key.
+ * @param xpub Extended public key for m/44'/60'/0'
+ * @param accountIndex Index of the address
+ * @returns Public key for m/44'/60'/0'/0/n where `n` is the address index
+ */
+declare function getAddressPublicKeyFromXPub(xpub: string, accountIndex: number): Buffer;
+
+/**
+ * Returns the address given a XPUB and account index.
+ * @returns Address of path `m/44'/60'/0'/0/n` where n is the index
+ * @param xpub XPUB for m/44'/60'/0'
+ * @param index Account index to get the address of.
+ */
+declare function getAddressFromXPub(xpub: string, index: number): string;
+
+/**
+ * Returns the extended public key of `m/44'/60'/0'`
+ * @param mnemonic
+ */
+declare function getXpubFromMnemonic$1(mnemonic: string): Promise<string>;
+
+declare function getEvmAddressFromPubKey(pubKey: Buffer): string;
+
+/**
+ * Given a public key, return the Bech32 bitcoin address.
+ * @param pubKey
+ * @param network BTC network to use for the address
+ */
+declare function getBtcAddressFromPubKey(pubKey: Buffer, network: Network): string;
+
+declare class LedgerSigner$1 extends AbstractSigner {
+    readonly type: string;
+    readonly path: string;
+    readonly provider: Provider | null;
+    readonly accountIndex: number;
+    readonly derivationSpec: DerivationPath;
+    transport: Transport;
+    _eth: Eth;
+    constructor(accountIndex: number | undefined, transport: Transport, derivationSpec: DerivationPath, provider?: Provider);
+    setTransport(t: Transport): void;
+    getAddress(): Promise<string>;
+    signMessage(message: BytesLike | string): Promise<string>;
+    signTransaction(transaction: TransactionRequest): Promise<string>;
+    connect(provider: Provider): LedgerSigner$1;
+    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
+}
+
+/**
+ * A wallet instance for the given private key. Can sign transactions.
+ */
+declare class BitcoinWallet extends BitcoinWalletAbstract {
+    keypair: ECPairInterface;
+    constructor(privKey: Buffer, provider: BitcoinProviderAbstract);
+    /**
+     *
+     * @param mnemonic The mnemonic phrase to derive the wallet from.
+     * @param accountIndex Used when deriving the private key from mnemonic. The path used is `m/44'/60'/0'/0/n` where `n` is the account index.
+     * @param provider
+     * @param derivationSpec Sets how account paths are generated. BIP44 (Default) or LedgerLive.
+     */
+    static fromMnemonic(mnemonic: string, accountIndex: number, provider: BitcoinProviderAbstract, derivationSpec?: DerivationPath): Promise<BitcoinWallet>;
+    /**
+     * Create a transaction from the given inputs and outputs, and sign it.
+     * @remarks Signs all inputs.
+     * @param ins Array of input UTXOs to consume
+     * @param outs Array of output UTXOs to create.
+     */
+    signTx(ins: BitcoinInputUTXO[], outs: BitcoinOutputUTXO[]): Promise<bitcoinjs_lib.Transaction>;
+    /**
+     * Create a bitcoin wallet using the private key of an Ethers wallet.
+     * @param wallet An Ethers wallet instance that has a private key.
+     * @param prov Bitcoin provider.
+     */
+    static fromEthersWallet(wallet: HDNodeWallet, prov: BitcoinProviderAbstract): BitcoinWallet;
+    /**
+     * Sings a given PSBT and returns the transaction.
+     * @remarks Signs all inputs.
+     * @param tx
+     */
+    signPsbt(tx: Psbt): bitcoinjs_lib.Transaction;
+}
+
+interface WalletPolicyDetails {
+    policy: WalletPolicy;
+    hmac: Buffer;
+}
+
+declare class BitcoinLedgerWallet extends BitcoinWalletAbstract {
+    private derivationPath;
+    protected transport: Transport;
+    private walletPolicyDetails;
+    /**
+     *
+     * @param publicKey Public key of the address
+     * @param derivationPath BIP44 derivation path of the publickey/address
+     * @param provider
+     * @param transport Ledger transport instance.
+     */
+    constructor(publicKey: Buffer, derivationPath: string, provider: BitcoinProviderAbstract, transport: Transport, walletPolicyDetails: WalletPolicyDetails);
+    /**
+     * Update the ledger transport used by this wallet.
+     * @param t
+     */
+    setTransport(t: Transport): void;
+    /**
+     * Creates a transaction with the given inputs & outputs and signs using the ledger.
+     * @param ins Input UTXOs for this transaction. Must be P2WPKH.
+     * @param outs Output UTXOs for this transaction.
+     * @param ledgerConfig
+     */
+    signTx(ins: BitcoinInputUTXO[], outs: BitcoinOutputUTXO[]): Promise<bitcoinjs_lib.Transaction>;
+}
+
+/**
+ * A wallet class for readonly wallet instances.
+ */
+declare class BitcoinWalletVoid extends BitcoinWalletAbstract {
+    constructor(publicKey: Buffer, provider: BitcoinProviderAbstract);
+    signTx(tx: any): any;
+}
+
+type ChainIDAlias = 'X' | 'P' | 'C';
+/**
+ * Types for parsed transaction
+ */
+type Tx = AddValidatorTx | AddDelegatorTx | ExportTx | ImportTx | BaseTx | CreateSubnetTx | CreateChainTx | AddSubnetValidatorTx | RemoveSubnetValidatorTx | AddPermissionlessValidatorTx | AddPermissionlessDelegatorTx | TransformSubnetTx | TransferSubnetOwnershipTx | UnknownTx;
+interface FeeData {
+    totalAvaxBurned: bigint;
+    totalAvaxOutput: bigint;
+    totalAvaxInput: bigint;
+    isValidAvaxBurnedAmount: boolean;
+    txFee: bigint;
+}
+interface TxBase extends FeeData {
+    type: string;
+    chain: VM;
+}
+declare enum TxType {
+    Base = "base",
+    AddValidator = "add_validator",
+    AddDelegator = "add_delegator",
+    Export = "export",
+    Import = "import",
+    CreateSubnet = "create_subnet",
+    CreateChain = "create_chain",
+    AddSubnetValidator = "add_subnet_validator",
+    RemoveSubnetValidator = "remove_subnet_validator",
+    AddPermissionlessValidator = "add_permissionless_validator",
+    AddPermissionlessDelegator = "add_permissionless_delegator",
+    TransformSubnet = "transform_subnet",
+    TransferSubnetOwnership = "transfer_subnet_ownership",
+    Unknown = "unknown"
+}
+interface BaseTx extends TxBase {
+    type: TxType.Base;
+    chain: VM;
+    outputs: {
+        assetId: string;
+        locktime: bigint;
+        threshold: bigint;
+        amount: bigint;
+        assetDescription?: Common.GetAssetDescriptionResponse;
+        owners: string[];
+        isAvax: boolean;
+    }[];
+    memo?: string;
+}
+interface AddValidatorTx extends TxBase {
+    type: TxType.AddValidator;
+    nodeID: string;
+    delegationFee: number;
+    start: string;
+    end: string;
+    rewardOwner: OutputOwners;
+    stake: bigint;
+    stakeOuts: TransferableOutput[];
+}
+interface AddDelegatorTx extends TxBase {
+    type: TxType.AddDelegator;
+    nodeID: string;
+    start: string;
+    end: string;
+    rewardOwner: OutputOwners;
+    stake: bigint;
+    stakeOuts: TransferableOutput[];
+}
+interface ExportTx extends TxBase {
+    type: TxType.Export;
+    destination: VM;
+    amount: bigint;
+}
+interface ImportTx extends TxBase {
+    type: TxType.Import;
+    source: VM;
+    amount: bigint;
+}
+interface CreateSubnetTx extends TxBase {
+    type: TxType.CreateSubnet;
+    threshold: number;
+    controlKeys: string[];
+}
+interface CreateChainTx extends TxBase {
+    type: TxType.CreateChain;
+    subnetID: string;
+    chainName: string;
+    chainID: string;
+    vmID: string;
+    fxIDs: string[];
+    genesisData: string;
+}
+interface AddSubnetValidatorTx extends TxBase {
+    type: TxType.AddSubnetValidator;
+    nodeID: string;
+    start: string;
+    end: string;
+    subnetID: string;
+    stake: bigint;
+}
+interface RemoveSubnetValidatorTx extends TxBase {
+    type: TxType.RemoveSubnetValidator;
+    nodeID: string;
+    subnetID: string;
+}
+interface AddPermissionlessValidatorTx extends TxBase {
+    type: TxType.AddPermissionlessValidator;
+    nodeID: string;
+    delegationFee: number;
+    start: string;
+    end: string;
+    rewardOwner: OutputOwners;
+    delegationRewardOwner: OutputOwners;
+    stake: bigint;
+    stakeOuts: TransferableOutput[];
+    subnetID: string;
+    publicKey: undefined | string;
+    signature: undefined | string;
+    signer: pvmSerial.Signer | pvmSerial.SignerEmpty;
+}
+interface AddPermissionlessDelegatorTx extends TxBase {
+    type: TxType.AddPermissionlessDelegator;
+    nodeID: string;
+    start: string;
+    end: string;
+    stake: bigint;
+    subnetID: string;
+    delegatorRewardsOwner: OutputOwners;
+    stakeOuts: TransferableOutput[];
+}
+interface TransformSubnetTx extends TxBase {
+    type: TxType.TransformSubnet;
+    subnetID: string;
+    assetID: string;
+    initialSupply: bigint;
+    maximumSupply: bigint;
+    minConsumptionRate: bigint;
+    maxConsumptionRate: bigint;
+    minValidatorStake: bigint;
+    maxValidatorStake: bigint;
+    minStakeDuration: number;
+    maxStakeDuration: number;
+    minDelegationFee: number;
+    minDelegatorStake: number;
+    maxValidatorWeightFactor: number;
+    uptimeRequirement: number;
+}
+interface TransferSubnetOwnershipTx extends TxBase {
+    type: TxType.TransferSubnetOwnership;
+    subnetID: string;
+    threshold: number;
+    controlKeys: string[];
+}
+interface UnknownTx extends TxBase {
+    type: TxType.Unknown;
+}
+/**
+ * Type Guards
+ */
+declare function isAddValidatorTx(tx: Tx): tx is AddValidatorTx;
+declare function isAddDelegatorTx(tx: Tx): tx is AddDelegatorTx;
+declare function isExportTx(tx: Tx): tx is ExportTx;
+declare function isImportTx(tx: Tx): tx is ImportTx;
+declare function isBaseTx(tx: Tx): tx is BaseTx;
+declare function isCreateSubnetTx(tx: Tx): tx is CreateSubnetTx;
+declare function isCreateChainTx(tx: Tx): tx is CreateChainTx;
+declare function isAddSubnetValidatorTx(tx: Tx): tx is AddSubnetValidatorTx;
+declare function isRemoveSubnetValidatorTx(tx: Tx): tx is RemoveSubnetValidatorTx;
+declare function isAddPermissionlessValidatorTx(tx: Tx): tx is AddPermissionlessValidatorTx;
+declare function isAddPermissionlessDelegatorTx(tx: Tx): tx is AddPermissionlessDelegatorTx;
+declare function isTransformSubnetTx(tx: Tx): tx is TransformSubnetTx;
+declare function isTransferSubnetOwnershipTx(tx: Tx): tx is TransferSubnetOwnershipTx;
+
+declare class AbstractProvider {
+    protected baseUrl: string;
+    protected context: Context.Context;
+    evmRpc: JsonRpcProvider$1;
+    constructor(baseUrl: string, context: Context.Context);
+    /**
+     * @link https://docs.ethers.io/v5/api/providers/provider/#Provider-getFeeData
+     */
+    getEvmFeeData(): Promise<ethers.FeeData>;
+    getContext(): Context.Context;
+    getChainID(chainAlias: ChainIDAlias): string;
+    getNetworkID(): number;
+    getHrp(): string;
+    getApiX(): avm.AVMApi;
+    getApiP(): pvm.PVMApi;
+    getApiC(): evm.EVMApi;
+    getApi(chain: ChainIDAlias): avm.AVMApi | pvm.PVMApi | evm.EVMApi;
+    getAvaxID(): string;
+    getAddress(publicKey: Buffer, chain: ChainIDAlias): string;
+    getAddressFromBuffer(address: Buffer, chain: ChainIDAlias): string;
+    /**
+     * Format an existing address to match the current network and given chain alias
+     * @param address an Avalanche bech32 address without chain prefix
+     * @param chain Target chain
+     */
+    formatAddress(address: string, chain: ChainIDAlias): string;
+    getApiByVM(vm: VM): avm.AVMApi | pvm.PVMApi | evm.EVMApi;
+    getApiByChainID(chainID: string): avm.AVMApi | pvm.PVMApi | evm.EVMApi | undefined;
+    issueTx(tx: avaxSerial.SignedTx): Promise<_avalabs_avalanchejs_dist_vms_common.IssueTxResponse>;
+    issueTxHex(txHex: string, vm: VM): Promise<_avalabs_avalanchejs_dist_vms_common.IssueTxResponse>;
+}
+
+declare class JsonRpcProvider extends AbstractProvider {
+    constructor(baseUrl: string, context: Context.Context);
+    static fromBaseURL(url: string): Promise<JsonRpcProvider>;
+    static getDefaultMainnetProvider(): JsonRpcProvider;
+    static getDefaultFujiProvider(): JsonRpcProvider;
+}
+
+/**
+ * Avalanche Mainnet context
+ */
+declare const MainnetContext: Context.Context;
+/**
+ * Avalanche Fuji testnet context
+ */
+declare const FujiContext: Context.Context;
+
+/**
+ * An  abstract class that that is shared by all wallet classes.
+ */
+declare abstract class WalletAbstract {
+    protected provider: AbstractProvider;
+    /**
+     * Returns all addresses used by this wallet for the given chain.
+     * @param chain
+     */
+    abstract getAddresses(chain: ChainIDAlias): string[];
+    /**
+     * Returns the C chain EVM address (hex).
+     */
+    abstract getAddressEVM(): string;
+    /**
+     * Get the address used by this wallet to receive funds.
+     * @param chain
+     */
+    abstract getCurrentAddress(chain: ChainIDAlias): string;
+    /**
+     * Get the address that will receive the "change" after transactions
+     * @param chain
+     */
+    abstract getChangeAddress(chain: ChainIDAlias): string;
+    /**
+     * Set the provider used by this wallet.
+     * @param provider
+     */
+    setProvider(provider: AbstractProvider): void;
+    /**
+     * Get the provider used by this wallet.
+     */
+    getProvider(): AbstractProvider;
+    /**
+     * Get UTXOs owned by the wallet's addresses for the given chain
+     * @param chain
+     */
+    getUTXOs(chain: 'X' | 'P'): Promise<utils.UtxoSet>;
+    getStake(): Promise<pvm.GetStakeResponse>;
+    /**
+     * Get atomic UTXOs for the given chain
+     * @param chain Which chain are the atomic UTXOs are on
+     * @param source What is the source chain of the atomic UTXOs
+     */
+    getAtomicUTXOs(chain: ChainIDAlias, source: ChainIDAlias): Promise<utils.UtxoSet>;
+    exportX(amount: bigint, utxoSet: utils.UtxoSet, destination: 'P' | 'C', toAddress?: string): Common.UnsignedTx;
+    importP(utxos: utils.UtxoSet, sourceChain: 'X' | 'C', toAddress?: string): Common.UnsignedTx;
+    importX(utxos: utils.UtxoSet, sourceChain: 'P' | 'C', toAddress?: string): Common.UnsignedTx;
+    /**
+     *
+     * @param utxos
+     * @param sourceChain
+     * @param baseFee in nAvax (EVM base fee)
+     * @param feeAssetId
+     * @param toAddress Must be hex EVM address.
+     */
+    importC(utxos: utils.UtxoSet, sourceChain: 'P' | 'X', baseFee: bigint, feeAssetId?: string, toAddress?: string): Common.UnsignedTx;
+    /**
+     *
+     * @param amount
+     * @param destination
+     * @param nonce
+     * @param baseFee Given in WEI
+     * @param toAddress
+     */
+    exportC(amount: bigint, destination: 'X' | 'P', nonce: bigint, baseFee: bigint, toAddress?: string): _avalabs_avalanchejs.EVMUnsignedTx;
+    /**
+     * Get the nonce of this wallet's C chain address
+     */
+    getNonce(): Promise<number>;
+    /**
+     * Export the given amount of AVAX from the P chain. Export fee is automatically added.
+     * @param amount
+     * @param utxoSet
+     * @param destination
+     * @param toAddress
+     */
+    exportP(amount: bigint, utxoSet: utils.UtxoSet, destination: 'X' | 'C', toAddress?: string): Common.UnsignedTx;
+    addValidator(utxos: utils.UtxoSet, nodeID: string, stakeAmount: bigint, startDate: bigint, endDate: bigint, delegationFee: number, config?: {
+        rewardAddress?: string;
+    }): Common.UnsignedTx;
+    addDelegator(utxos: utils.UtxoSet, nodeID: string, stakeAmount: bigint, startDate: bigint, endDate: bigint, config?: {
+        rewardAddress?: string;
+    }): Common.UnsignedTx;
+    consolidateP(utxoSet: utils.UtxoSet, amount: bigint, toAddress?: string, options?: Common.SpendOptions): Common.UnsignedTx;
+    baseTX(utxoSet: utils.UtxoSet, chain: 'X' | 'P', toAddress: string, amountsPerAsset: Record<string, bigint>, options?: Common.SpendOptions, fromAddresses?: string[]): Common.UnsignedTx;
+    createBlockchain(utxoSet: utils.UtxoSet, subnetId: string, chainName: string, vmID: string, fxIds: string[], genesisData: Record<string, unknown>, subnetAuth: number[], options?: Common.SpendOptions, fromAddresses?: string[]): Common.UnsignedTx;
+    createSubnet(utxoSet: utils.UtxoSet, rewardAddresses: string[], fromAddresses?: string[], options?: Common.SpendOptions, threshold?: number, locktime?: bigint): Common.UnsignedTx;
+    addSubnetValidator(utxoSet: utils.UtxoSet, nodeId: string, start: bigint, end: bigint, weight: bigint, subnetId: string, subnetAuth: number[], fromAddresses?: string[], options?: Common.SpendOptions): Common.UnsignedTx;
+    /**
+     *
+     * @param utxoSet The transaction will be constructed from these UTXOs.
+     * @param nodeId The validating node id
+     * @param start Start date of the validation period in UNIX time
+     * @param end End date of the validation period in UNIX time
+     * @param weight Stake amount given in nAVAX
+     * @param subnetId The subnet id as a hexadecimal string
+     * @param shares The fee this validator charges delegators as a percentage, times 10,000. Ex. a value of 300,000 means they take 30% of rewards from delegators.
+     * @param fromAddresses Only utxos from these addresses will be used
+     * @param rewardAddresses Will use active address if not provided. Given addresses will share the reward UTXO.
+     * @param delegatorRewardAddresses Will use active address if not provided. Given addresses will share the delegator fee UTXO.
+     * @param publicKey the BLS public key, If the subnet is the primary network. Can be found in the Node on startup.
+     * @param signature the BLS signature, If the subnet is the primary network. Can be found in the Node on startup.
+     * @param options
+     */
+    addPermissionlessValidator(utxoSet: utils.UtxoSet, nodeId: string, start: bigint, end: bigint, weight: bigint, subnetId: string, shares: number, fromAddresses?: string[], rewardAddresses?: string[], delegatorRewardAddresses?: string[], publicKey?: Buffer, signature?: Buffer, options?: Common.SpendOptions): Common.UnsignedTx;
+    /**
+     *
+     * @param utxoSet The transaction will be constructed from these UTXOs.
+     * @param nodeId The validating node id
+     * @param start Start date of the validation period in UNIX time
+     * @param end End date of the validation period in UNIX time
+     * @param weight Stake amount given in nAVAX
+     * @param subnetId The subnet id as a hexadecimal string
+     * @param fromAddresses Only utxos from these addresses will be used
+     * @param rewardAddresses Will use active address if not provided. Given addresses will share the reward UTXO.
+     * @param options
+     */
+    addPermissionlessDelegator(utxoSet: utils.UtxoSet, nodeId: string, start: bigint, end: bigint, weight: bigint, subnetId: string, fromAddresses?: string[], rewardAddresses?: string[], options?: Common.SpendOptions): Common.UnsignedTx;
+    removeSubnetValidator(utxoSet: utils.UtxoSet, nodeId: string, subnetId: string, subnetAuth: number[], fromAddresses?: string[], options?: Common.SpendOptions): Common.UnsignedTx;
+    transferSubnetOwnershipTx(utxoSet: utils.UtxoSet, subnetId: string, subnetAuth: number[], subnetOwners: string[], fromAddresses?: string[], options?: Common.SpendOptions, threshold?: number, locktime?: bigint): Common.UnsignedTx;
+    transformSubnetTx(utxoSet: utils.UtxoSet, subnetId: string, assetId: string, initialSupply: bigint, maximumSupply: bigint, minConsumptionRate: bigint, maxConsumptionRate: bigint, minValidatorStake: bigint, maxValidatorStake: bigint, minStakeDuration: number, maxStakeDuration: number, minDelegationFee: number, minDelegatorStake: number, maxValidatorWeightFactor: number, uptimeRequirement: number, subnetAuth: number[], fromAddresses?: string[], options?: Common.SpendOptions): Common.UnsignedTx;
+    protected constructor(provider: AbstractProvider);
+}
+
+/**
+ * A wallet class that has the same static address for X/P/C chains.
+ */
+declare class WalletVoid extends WalletAbstract {
+    protected pubkeyXP: Buffer;
+    protected pubkeyC: Buffer;
+    /**
+     *
+     * @param pubkeyXP Public key of the X/P Chain address
+     * @param pubkeyC Public key of the C Chain address
+     * @param prov
+     */
+    constructor(pubkeyXP: Buffer, pubkeyC: Buffer, prov: AbstractProvider);
+    /**
+     * Creates a readonly wallet with the given public keys.
+     * @param pubkeyXP
+     * @param pubkeyC
+     * @param prov
+     */
+    static fromPublicKey(pubkeyXP: Buffer, pubkeyC: Buffer, prov: AbstractProvider): WalletVoid;
+    static fromMnemonic(mnemonic: string, pathXP: string, pathC: string, provider: AbstractProvider): WalletVoid;
+    /**
+     * Returns the address as a X, P, or C chain Bech32 address
+     * @param chainIdAlias X, P, or C
+     */
+    getAddress(chainIdAlias: ChainIDAlias): string;
+    /**
+     * Return the EVM address (hex) used by the C chain.
+     */
+    getAddressEVM(): string;
+    getAddresses(chain: ChainIDAlias): string[];
+    getChangeAddress(chain: ChainIDAlias): string;
+    getCurrentAddress(chain: ChainIDAlias): string;
+}
+
+declare function isObsidianApp(t: Transport): Promise<boolean>;
+
+interface LedgerProvider {
+    type: LedgerProviderType;
+    getApp(t: Transport): AppZondax;
+    getAddress(t: Transport, path: Bip32Path, config: {
+        show: boolean;
+        hrp: string;
+    }): Promise<{
+        publicKey: Buffer;
+    }>;
+    getXPUB(t: Transport, path: string): Promise<{
+        pubKey: Buffer;
+        chainCode: Buffer;
+    }>;
+    signHash(t: Transport, hash: Buffer, accountPath: Bip32Path, signers: Bip32Path[]): Promise<{
+        hash: Buffer;
+        signatures: Map<string, Buffer>;
+    }>;
+    /**
+     *
+     * @param t Ledger transport instance
+     * @param tx
+     * @param accountPath eg. m/44'/9000'/0'
+     * @param signers eg. [0/0, 1/0]
+     * @param changePaths eg. [0/0, 1/0]
+     */
+    signTx(t: Transport, tx: Buffer, accountPath: Bip32Path, signers: Bip32Path[], changePaths?: Bip32Path[]): Promise<{
+        signatures: Map<string, Buffer>;
+    } & Partial<ResponseBase>>;
+    getVersion(t: Transport): Promise<string>;
+}
+type LedgerProviderType = 'obsidian' | 'zondax';
+
+/**
+ * Get the correct ledger provider given a transport instance.
+ * @param t
+ */
+declare function getLedgerProvider(t: Transport): Promise<LedgerProvider>;
+
+/**
+ * A keyless wallet that cannot sign transactions.
+ * It is used to fetch UTXOs and construct transactions for a list of addresses.
+ */
+declare class AddressWallet extends WalletAbstract {
+    protected addressC: string;
+    protected addressCoreEth: string;
+    protected xpAddresses: string[];
+    protected xpChangeAddress: string;
+    /**
+     *
+     * @param addressC the EVM address (hex) used by the C chain.
+     * @param addressCoreEth the CoreEth address used by the C chain.
+     * @param xpAddresses a list of XP addresses. The first in the list is the primary address.
+     * @param xpChangeAddress change address to use for X/P chain transactions
+     * @param prov
+     */
+    constructor(addressC: string, addressCoreEth: string, xpAddresses: string[], xpChangeAddress: string, prov: AbstractProvider);
+    /**
+     * Set the change address to use with X/P chain transactions
+     * @param address
+     */
+    setChangeAddress(address: string): void;
+    /**
+     * Return the EVM address (hex) used by the C chain.
+     */
+    getAddressEVM(): string;
+    /**
+     * Return the addresses used by this wallet for the given chain alias.
+     * @param chain X/P/C chain alias
+     */
+    getAddresses(chain: ChainIDAlias): string[];
+    getChangeAddress(chain: ChainIDAlias): string;
+    /**
+     * For X and P, returns the 1st address in the XP Addresses array. For C, returns the CoreEth address.
+     * @param chain Which chain to get the address for
+     */
+    getCurrentAddress(chain: ChainIDAlias): string;
+}
+
+interface PubKeyCache {
+    [path: string]: Buffer;
+}
+/**
+ * This wallet class uses dynamic address for X/P chains and static for C chain. It replicates the wallet logic used in the Web Wallet.
+ */
+declare class MnemonicWalletVoid extends WalletAbstract {
+    protected readonly avmXpub: string;
+    /**
+     * Node for m/44'/9000'/0'
+     * @private
+     */
+    protected accountNode: BIP32Interface;
+    /**
+     * EVM Wallet instance of m/44'/60'/0'/0/0
+     * @private
+     */
+    private evmWallet;
+    /**
+     * Index of the current external address
+     */
+    protected externalIndex: number;
+    /**
+     * Index of the current internal (change) address
+     */
+    protected internalIndex: number;
+    /**
+     * Derived pubkeys will be stored here.
+     * @protected
+     */
+    protected pubkeyCache: PubKeyCache;
+    /**
+     *
+     * @param avmXpub XPUB of m/44'/9000'/0'
+     * @param evmPubKey Public Key of m/44'/60'/0'/0/0
+     * @param provider
+     */
+    constructor(avmXpub: string, evmPubKey: Buffer, provider: AbstractProvider);
+    static fromMnemonic(mnemonic: string, provider: AbstractProvider): MnemonicWalletVoid;
+    /**
+     * Set the current external index of this wallet.
+     * @param index
+     */
+    setExternalIndex(index: number): void;
+    /**
+     * Set the current internal index of this wallet.
+     * @param index
+     */
+    setInternalIndex(index: number): void;
+    /**
+     * Returns the public key for the given index. Used for X/P addresses. Results are cached.
+     * @param index
+     * @param isChange
+     * @private
+     */
+    private getPubKeyAtIndex;
+    getAddressAtIndex(index: number, isChange: boolean | undefined, chain: 'X' | 'P'): string;
+    getExternalAddresses(chain: 'X' | 'P'): string[];
+    getInternalAddresses(chain: 'X'): string[];
+    getAddresses(chain: ChainIDAlias): string[];
+    getChangeAddress(chain: ChainIDAlias): string;
+    getCurrentAddress(chain: ChainIDAlias): string;
+    /**
+     * Increment the current index used for internal/external addresses.
+     * @param external
+     */
+    incrementIndex(external: boolean): void;
+    getAddressEVM(): string;
+    getActiveIndices(): {
+        external: number;
+        internal: number;
+    };
+    getInternalRawAddresses(): Buffer[];
+    getExternalRawAddresses(): Buffer[];
+    getRawAddressC(): Buffer;
+}
+
+interface SignTxRequest {
+    tx: UnsignedTx | EVMUnsignedTx;
+    transport?: Transport;
+    externalIndices?: number[];
+    internalIndices?: number[];
+}
+interface SignTxBufferRequest {
+    buffer: Buffer;
+    chain: ChainIDAlias;
+    transport?: Transport;
+    signers?: Bip32Path[];
+    change?: Bip32Path[];
+}
+interface SignMessageRequest {
+    message: string;
+    chain: ChainIDAlias;
+    transport?: Transport;
+    signer?: Bip32Path;
+}
+interface Signer {
+    signTx(txRequest: SignTxRequest): Promise<UnsignedTx>;
+    signTxBuffer(txRequest: SignTxBufferRequest): Promise<Buffer[]>;
+    signMessage(request: SignMessageRequest): Promise<Buffer>;
+}
+interface LedgerGetXpubResponse {
+    public_key: Buffer;
+    chain_code: Buffer;
+}
+
+/**
+ * Ledger wallet class used by the legacy Web Wallet.
+ * Uses dynamic addresses for X and P Chains.
+ */
+declare class LedgerWallet extends MnemonicWalletVoid implements Signer {
+    /**
+     *
+     * @param xpub xpub of m/44'/9000'/0'
+     * @param evmPubKey of m/44'/60'/0'/0/0
+     * @param provider
+     */
+    constructor(xpub: string, evmPubKey: Buffer, provider: AbstractProvider);
+    private getAdditionalAddressesByIndices;
+    /**
+     * Create a ledger wallet from an active transport.
+     * @param t
+     * @param provider
+     */
+    static fromTransport(t: Transport, provider: AbstractProvider): Promise<LedgerWallet>;
+    static getAccountPath(chain: ChainIDAlias): "m/44'/9000'/0'" | "m/44'/60'/0'";
+    signMessage(request: SignMessageRequest): Promise<Buffer>;
+    /**
+     * Only returns the owned addresses and their derivation path
+     * @param addresses An array of address buffers
+     * @param additionalExternalAddresses Optional array of external account indices
+     * @param additionalInternalAddresses Optional array of internal account indices
+     * @return Map of addressHex to derivationPath
+     */
+    filterOwnedAddresses(addresses: Buffer[], additionalExternalAddresses?: string[], additionalInternalAddresses?: string[]): Set<string>;
+    signTx(txRequest: SignTxRequest): Promise<UnsignedTx>;
+    signTxBuffer(txRequest: SignTxBufferRequest): Promise<Buffer[]>;
+}
+
+/**
+ * A signer interface for mnemonic wallets that mimics the Legacy Web Wallet. This wallet has
+ * multiple addresses for X/P chains, its address index can be incremented to give the user a new address after every transaction.
+ */
+declare class MnemonicWallet extends MnemonicWalletVoid implements Signer {
+    private evmPrivKey;
+    protected accountNode: BIP32Interface;
+    /**
+     *
+     * @param avaxXPriv Bip32 node for m/44'/9000'/0'
+     * @param evmPrivKey of m/44'/60'/0'/0/0
+     * @param provider
+     */
+    constructor(avaxXPriv: string, evmPrivKey: Buffer, provider: AbstractProvider);
+    static fromMnemonic(mnemonic: string, provider: AbstractProvider): MnemonicWallet;
+    signTx(request: SignTxRequest): Promise<UnsignedTx>;
+    private getExternalPrivateKeys;
+    private getInternalPrivateKeys;
+    private getSigningKeys;
+    signTxBuffer(request: SignTxBufferRequest): Promise<Buffer[]>;
+    signMessage(request: SignMessageRequest): Promise<Buffer>;
+}
+
+/**
+ * A signer wallet class that has single key for X/P chains, and another key for C chain. Same key
+ * can be used for both.
+ * This wallet type does not use dynamic addresses for X and P chains. Only a single address is used.
+ */
+declare class StaticSigner extends WalletVoid implements Signer {
+    protected privKeyXP: Buffer;
+    protected privKeyC: Buffer;
+    constructor(privKeyXP: Buffer, privKeyC: Buffer, prov: AbstractProvider);
+    /**
+     * Create a wallet instance using a mnemonic.
+     * @param mnemonic A valid mnemonic string
+     * @param pathXP BIP44 derivation path for the X/P chain address
+     * @param pathC BIP44 derivation path for the C chain address
+     * @param provider
+     */
+    static fromMnemonic(mnemonic: string, pathXP: string, pathC: string, provider: AbstractProvider): StaticSigner;
+    signMessage(request: SignMessageRequest): Promise<Buffer>;
+    /**
+     * Return the private key for the given chain
+     * @param chain
+     * @protected
+     */
+    protected getSigningKey(chain: ChainIDAlias): Buffer;
+    /**
+     * Sign Avalanche X/P/C chain transactions in place.
+     * @param request
+     */
+    signTx(request: SignTxRequest): Promise<_avalabs_avalanchejs.UnsignedTx | _avalabs_avalanchejs.EVMUnsignedTx>;
+    signTxBuffer(request: SignTxBufferRequest): Promise<Buffer[]>;
+}
+
+/**
+ * A wallet class that can sign X/P and C transactions with the provided mnemonic code.
+ * It can:
+ *  - act like the {@link StaticSigner} by only using the signing key of the active account
+ *  - sign X/P transactions containing multiple inputs coming from different addresses
+ * However, it doesn't support dynamic addresses like {@link MnemonicWallet} does.
+ */
+declare class SimpleSigner implements Signer {
+    /**
+     * Node for `m/44'/9000'/0'`
+     * @private {BIP32Interface}
+     */
+    private accountNodeXP;
+    /**
+     * Node for `m/44'/60'/0'/0/n`
+     * @private {BIP32Interface}
+     */
+    private signerNodeEVM;
+    /**
+     * The primary account's index used for signing C transactions and X/P transactions with static addresses
+     * @private {number}
+     */
+    private activeAccountIndex;
+    /**
+     * @param {string} mnemonic - mnemonic code as defined in {@link https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki}
+     * @param {number} activeAccountIndex - the index of the primary account used for static signing
+     */
+    constructor(mnemonic: string, activeAccountIndex: number);
+    /**
+     * Generate X/P private keys for custom address indices
+     * @param {number[]} customIndices - optional list of custom address indices
+     * @param {boolean} isChange - optional flag for deriving internal / external addresses from the indices
+     * @returns {Buffer[]} list of private key buffers
+     */
+    private getAdditionalKeys;
+    /**
+     * Gets the proper list of signing keys for the given VM
+     * @param {VM} vm - the target VM's type
+     * @param {number[]} externalIndices - optional list of custom external address indices
+     * @param {number[]} internalIndices - optional list of custom internal address indices
+     * @returns {Buffer[]} list of private key raw bytes
+     */
+    private getSigningKeys;
+    signTx(request: SignTxRequest): Promise<_avalabs_avalanchejs.UnsignedTx | _avalabs_avalanchejs.EVMUnsignedTx>;
+    signTxBuffer(request: SignTxBufferRequest): Promise<void>;
+    /**
+     * Returns the X/P/C Chain bip32 node for the active signer.
+     * @private
+     */
+    private getActiveAccountNode;
+    /**
+     * Signs the given message with the active X/P Chain account.
+     * Used for signing primary network messages.
+     * @param request
+     */
+    signMessage(request: SignMessageRequest): Promise<Buffer>;
+}
+
+/**
+ * Ledger wallet that uses a single address for X/P chains, and another for C chain. Same address can be used for all.
+ */
+declare class LedgerSigner extends WalletVoid implements Signer {
+    private pathXP;
+    private pathC;
+    /**
+     *
+     * @param pubkey public key of the address account
+     * @param prov Avalanche network provider
+     * @param path BIP44 derivation path for the given public key
+     */
+    constructor(pubkeyXP: Buffer, pathXP: string, pubkeyC: Buffer, pathC: string, prov: AbstractProvider);
+    /**
+     *
+     * @param transport Active transport instance
+     * @param pathXP BIP44 path for the X/P chain address
+     * @param pathC BIP44 path for the C chain address
+     * @param provider
+     */
+    static fromTransport(transport: Transport, pathXP: string, pathC: string, provider: AbstractProvider): Promise<LedgerSigner>;
+    signMessage(request: SignMessageRequest): Promise<Buffer>;
+    /**
+     * Returns the full HD path that will be used for signing.
+     * @return BIP44 path, ex. m/44'/60'/0'/0/0 for C chain
+     */
+    getFullSignerPath(chain: ChainIDAlias): string;
+    /**
+     * Only returns the last two indices of the full signer path
+     * @return ex. 0/0, 0/1
+     */
+    getPartialSignerPath(chain: ChainIDAlias): string;
+    /**
+     * Returns the correct HD path for the given chain.
+     * @return ex. m/44'/60'/0'
+     */
+    getAccountPath(chain: ChainIDAlias): string;
+    signTx(txRequest: SignTxRequest): Promise<UnsignedTx>;
+    signTxBuffer(txRequest: SignTxBufferRequest): Promise<Buffer[]>;
+}
+
+/**
+ * A wallet class that can sign X/P and C transactions.
+ * It can:
+ *  - act like the {@link LedgerSigner} by only using the signing key of the active account
+ *  - sign X/P transactions containing multiple inputs coming from different addresses with the provided extended public key
+ * However, it doesn't support dynamic addresses like {@link LedgerWallet} does.
+ */
+declare class SimpleLedgerSigner implements Signer {
+    private activeAccountIndex;
+    private provider;
+    private accountNode;
+    /**
+     * @param {number} activeAccountIndex - the index of the primary account used for static signing
+     * @param {string} xpubXP - optional extended public key of `m/44'/9000'/0`
+     */
+    constructor(activeAccountIndex: number, provider: JsonRpcProvider, xpubXP?: string);
+    private reSerializeTx;
+    private getChainAlias;
+    private getAccountPath;
+    private getAddressOfPath;
+    private getAddressPathMap;
+    private getAddressBipPaths;
+    signTx(txRequest: SignTxRequest): Promise<UnsignedTx>;
+    signTxBuffer(txRequest: SignTxBufferRequest): Promise<Buffer[]>;
+    signMessage(request: SignMessageRequest): Promise<Buffer>;
+}
+
+declare const addSignaturesToAvalancheTx: ({ transactionHex, signatures, chainAlias, provider, utxos, }: {
+    transactionHex: string;
+    signatures: Uint8Array[];
+    chainAlias: ChainIDAlias;
+    provider: JsonRpcProvider;
+    utxos: Utxo[];
+}) => Promise<{
+    signedTxHex: string;
+    hasAllSignatures: boolean;
+}>;
+
+type GlacierOutput = Utxo$1 | PChainUtxo;
+declare const convertGlacierUtxo: (glacierUtxo: GlacierOutput, isTestnet: boolean) => Utxo;
+
+type Params$2 = {
+    txBytes: Uint8Array;
+    fromAddress: string;
+    vm: VM;
+    utxos: Utxo[];
+};
+declare const createAvalancheEvmUnsignedTx: ({ txBytes, fromAddress, vm, utxos, }: Params$2) => Promise<UnsignedTx>;
+
+type Params$1 = {
+    tx: avaxSerial.AvaxTx;
+    fromAddressBytes?: Uint8Array[];
+    provider: JsonRpcProvider;
+    credentials?: Credential[];
+    utxos: Utxo[];
+};
+declare const createAvalancheUnsignedTx: ({ tx, fromAddressBytes, provider, credentials, utxos, }: Params$1) => Promise<UnsignedTx>;
+
+declare function digestMessage(message: string): Buffer;
+
+/**
+ * Derive X or P Chain address from a given extended public key.
+ * @param xpub of m/44'/9000'/0'
+ * @param addressIndex will add 0/n to account path where n is the account index
+ * @param provider For parsing the bech32 address with the correct HRP
+ * @param chain X/P/C to prepend to the address
+ * @param isChange if true derived addresses will have the change index set to `1`. ex. `m/44'/9000'/0'/1/0
+ */
+declare function getAddressFromXpub(xpub: string, addressIndex: number, provider: AbstractProvider, chain: ChainIDAlias, isChange?: boolean): string;
+
+/**
+ * Get the address public key from an account xpub
+ * @param xpub xpub string for the path m/44'/9000'/0'
+ * @param index
+ * @return public key of m/44'/9000'/0'/0/index
+ */
+declare function getAddressPublicKeyFromXpub(xpub: string, index: number): Buffer;
+
+/**
+ * Fetches all UTXOs for all addresses given. Splits addresses in to groups if necessary.
+ * @param addrs Addresses to get UTXOs for, address chain must match the api instance chain.
+ * @param api API instance for the chain
+ * @param config
+ */
+declare function getUTXOsForAddresses(addrs: string[], api: avm.AVMApi | pvm.PVMApi | evm.EVMApi, config?: Common.GetUTXOsInput): Promise<utils.UtxoSet>;
+/**
+ * Gets all UTXOs by pagination.
+ * @param api
+ * @param config
+ */
+declare function getPaginatedUTXOs(api: avm.AVMApi | pvm.PVMApi | evm.EVMApi, config: Common.GetUTXOsInput): Promise<utils.UtxoSet>;
+
+interface GetAvaxBalanceDict {
+    /**
+     * UTXOS that have a locktime in the future
+     */
+    locked: bigint;
+    /**
+     * UTXOs that can be consumed
+     */
+    available: bigint;
+    /**
+     * UTXOs with a threshold of > 1
+     */
+    multisig: bigint;
+    /**
+     * LockedStakeable UTXOs, only on P chain
+     */
+    lockedStakeable: bigint;
+    total: bigint;
+}
+/**
+ * Sum the UTXOs into multiple buckets.
+ * @param utxoSet
+ * @param assetID
+ */
+declare function getAssetBalance(utxoSet: utils.UtxoSet, assetID: string): GetAvaxBalanceDict;
+
+/**
+ * Get the current p-chain timestamp in unix
+ */
+declare function getPchainUnixNow(isTestnet: boolean): Promise<bigint>;
+
+interface GetStakedAvaxBalanceDict {
+    /**
+     * UTXOs that are NOT of type LockedStakeable out
+     */
+    unlockedStaked: bigint;
+    /**
+     * UTXOs that are of type LockedStakeable out
+     */
+    lockedStaked: bigint;
+    total: bigint;
+}
+declare function getStakedAssetBalance(stakeResponse: pvm.GetStakeResponse): GetStakedAvaxBalanceDict;
+
+declare function getStakeForAddresses(addresses: string[], api: pvm.PVMApi): Promise<pvm.GetStakeResponse>;
+
+/**
+ * Get the current UNIX time stamp as a BigInt
+ */
+declare function getUnixNow(): bigint;
+
+type UtxoInfo = {
+    utxoId: string;
+    assetId: string;
+    locktime: bigint;
+    stakeableLocktime: bigint;
+    threshold: number;
+    amount: bigint;
+};
+declare const getUtxoInfo: (utxo: Utxo) => UtxoInfo;
+
+type Params = {
+    transactionHex: string;
+    chainAlias: ChainIDAlias;
+    isTestnet: boolean;
+    url: string;
+    token?: string;
+};
+declare const getUtxosByTxFromGlacier: ({ transactionHex, chainAlias, isTestnet, url, token, }: Params) => Promise<Utxo[]>;
+
+declare const getVmByChainAlias: (chainAlias: string) => "EVM" | "AVM" | "PVM";
+
+/**
+ * Get the xpub for m/44'/9000'/0' from the given mnemonic
+ * @param mnemonic
+ */
+declare function getXpubFromMnemonic(mnemonic: string): string;
+
+/**
+ * Verify the given address is a valid Avalanche bech32 address
+ * @param address The address to test
+ * @param hasChainId if true requires chain alias prefix (X-, P-, C-), if false address must not have a prefix
+ */
+declare function isBech32Address(address: string, hasChainId?: boolean): boolean;
+
+/**
+ * Returns human readable data from a given a transaction buffer,
+ */
+declare function parseAvalancheTx(unsignedTx: Common.UnsignedTx, provider: JsonRpcProvider, currentAddress: string): Promise<Tx>;
+
+declare const emptySignature: Signature;
+declare const populateCredential: (indices: number[], existingCredentialData?: {
+    unsignedTx: UnsignedTx;
+    credentialIndex: number;
+}) => Signature[];
+
+declare function signedTxToHex(signedTx: avaxSerial.SignedTx): string;
+
+/**
+ * The UTXOs will be sorted in the following order.
+ * 1- LockedStakeable UTXOs with the highest locktime to lowest
+ * 2- Highest value UTXOs to lowest
+ * @remark Does not check for locked UTXOs
+ */
+declare function sortUTXOsStaking(utxos: Utxo[]): Utxo[];
+declare function sortUTXOsByAmount(utxos: Utxo[], isDescending: boolean): Utxo[];
+declare const sortUTXOsByAmountDescending: (utxos: Utxo[]) => Utxo[];
+declare const sortUTXOsByAmountAscending: (utxos: Utxo[]) => Utxo[];
+
+/**
+ * The list of transaction types supported by `getMaximumUtxoSet`.
+ */
+declare enum SizeSupportedTx {
+    AddValidator = 0,
+    AddDelegator = 1,
+    ExportP = 2,
+    ImportP = 3,
+    AddPermissionlessValidator = 4,
+    AddPermissionlessDelegator = 5,
+    BaseP = 6,
+    ConsolidateP = 7
+}
+/**
+ * 64 KB.
+ * @see https://github.com/ava-labs/avalanchego/blob/aa481ddce393fbb3ab957e4c8f87d5cd50b5eb4e/vms/platformvm/txs/mempool/mempool.go#L21-L23
+ */
+declare const P_CHAIN_TX_SIZE_LIMIT = 65536;
+/**
+ * This method will sort `utxos` depending on the `sizeSupportedTx`'s configured sorting algorithm.
+ * It then performs a binary search over the sorted UTXOs to determine the largest prefix of the sorted array
+ * which can be consumed while still remaining under the byte size limit
+ * @param wallet - an instance of the `WalletAbstract` class, with utilities for creating unsigned transactions
+ * @param utxos - list of UTXOs to be consumed by the transaction. **WARNING:** `utxos` will be sorted **IN PLACE** by this function!
+ * @param sizeSupportedTx - one of the supported transaction types
+ * @param limit - optional - byte size limit, defaults to 64kb.
+ * @returns the largest prefix of `utxos` before hitting the size limit. If no such prefix exists, then an empty array.
+ */
+declare function getMaximumUtxoSet(wallet: WalletAbstract$1, utxos: Utxo[], sizeSupportedTx: SizeSupportedTx, limit?: number): Utxo[];
+
+/**
+ * Verifies the given derivation path is valid, starts with `m`, and of the right length
+ * @param path BIP44 derivation path
+ */
+declare function verifyDerivationPath(path: string): any;
+
+type index_AbstractProvider = AbstractProvider;
+declare const index_AbstractProvider: typeof AbstractProvider;
+type index_AddDelegatorTx = AddDelegatorTx;
+type index_AddPermissionlessDelegatorTx = AddPermissionlessDelegatorTx;
+type index_AddPermissionlessValidatorTx = AddPermissionlessValidatorTx;
+type index_AddSubnetValidatorTx = AddSubnetValidatorTx;
+type index_AddValidatorTx = AddValidatorTx;
+type index_AddressWallet = AddressWallet;
+declare const index_AddressWallet: typeof AddressWallet;
+type index_BaseTx = BaseTx;
+type index_ChainIDAlias = ChainIDAlias;
+type index_CreateChainTx = CreateChainTx;
+type index_CreateSubnetTx = CreateSubnetTx;
+type index_ExportTx = ExportTx;
+type index_FeeData = FeeData;
+declare const index_FujiContext: typeof FujiContext;
+type index_GetAvaxBalanceDict = GetAvaxBalanceDict;
+type index_GetStakedAvaxBalanceDict = GetStakedAvaxBalanceDict;
+type index_GlacierOutput = GlacierOutput;
+type index_ImportTx = ImportTx;
+type index_JsonRpcProvider = JsonRpcProvider;
+declare const index_JsonRpcProvider: typeof JsonRpcProvider;
+type index_LedgerGetXpubResponse = LedgerGetXpubResponse;
+type index_LedgerSigner = LedgerSigner;
+declare const index_LedgerSigner: typeof LedgerSigner;
+type index_LedgerWallet = LedgerWallet;
+declare const index_LedgerWallet: typeof LedgerWallet;
+declare const index_MainnetContext: typeof MainnetContext;
+type index_MnemonicWallet = MnemonicWallet;
+declare const index_MnemonicWallet: typeof MnemonicWallet;
+type index_MnemonicWalletVoid = MnemonicWalletVoid;
+declare const index_MnemonicWalletVoid: typeof MnemonicWalletVoid;
+declare const index_P_CHAIN_TX_SIZE_LIMIT: typeof P_CHAIN_TX_SIZE_LIMIT;
+type index_RemoveSubnetValidatorTx = RemoveSubnetValidatorTx;
+type index_SignMessageRequest = SignMessageRequest;
+type index_SignTxBufferRequest = SignTxBufferRequest;
+type index_SignTxRequest = SignTxRequest;
+type index_Signer = Signer;
+type index_SimpleLedgerSigner = SimpleLedgerSigner;
+declare const index_SimpleLedgerSigner: typeof SimpleLedgerSigner;
+type index_SimpleSigner = SimpleSigner;
+declare const index_SimpleSigner: typeof SimpleSigner;
+type index_SizeSupportedTx = SizeSupportedTx;
+declare const index_SizeSupportedTx: typeof SizeSupportedTx;
+type index_StaticSigner = StaticSigner;
+declare const index_StaticSigner: typeof StaticSigner;
+type index_TransferSubnetOwnershipTx = TransferSubnetOwnershipTx;
+type index_TransformSubnetTx = TransformSubnetTx;
+type index_Tx = Tx;
+type index_TxBase = TxBase;
+type index_TxType = TxType;
+declare const index_TxType: typeof TxType;
+type index_UnknownTx = UnknownTx;
+type index_UtxoInfo = UtxoInfo;
+type index_WalletAbstract = WalletAbstract;
+declare const index_WalletAbstract: typeof WalletAbstract;
+type index_WalletVoid = WalletVoid;
+declare const index_WalletVoid: typeof WalletVoid;
+declare const index_addSignaturesToAvalancheTx: typeof addSignaturesToAvalancheTx;
+declare const index_convertGlacierUtxo: typeof convertGlacierUtxo;
+declare const index_createAvalancheEvmUnsignedTx: typeof createAvalancheEvmUnsignedTx;
+declare const index_createAvalancheUnsignedTx: typeof createAvalancheUnsignedTx;
+declare const index_digestMessage: typeof digestMessage;
+declare const index_emptySignature: typeof emptySignature;
+declare const index_getAddressFromXpub: typeof getAddressFromXpub;
+declare const index_getAddressPublicKeyFromXpub: typeof getAddressPublicKeyFromXpub;
+declare const index_getAssetBalance: typeof getAssetBalance;
+declare const index_getLedgerProvider: typeof getLedgerProvider;
+declare const index_getMaximumUtxoSet: typeof getMaximumUtxoSet;
+declare const index_getPaginatedUTXOs: typeof getPaginatedUTXOs;
+declare const index_getPchainUnixNow: typeof getPchainUnixNow;
+declare const index_getStakeForAddresses: typeof getStakeForAddresses;
+declare const index_getStakedAssetBalance: typeof getStakedAssetBalance;
+declare const index_getUTXOsForAddresses: typeof getUTXOsForAddresses;
+declare const index_getUnixNow: typeof getUnixNow;
+declare const index_getUtxoInfo: typeof getUtxoInfo;
+declare const index_getUtxosByTxFromGlacier: typeof getUtxosByTxFromGlacier;
+declare const index_getVmByChainAlias: typeof getVmByChainAlias;
+declare const index_getXpubFromMnemonic: typeof getXpubFromMnemonic;
+declare const index_isAddDelegatorTx: typeof isAddDelegatorTx;
+declare const index_isAddPermissionlessDelegatorTx: typeof isAddPermissionlessDelegatorTx;
+declare const index_isAddPermissionlessValidatorTx: typeof isAddPermissionlessValidatorTx;
+declare const index_isAddSubnetValidatorTx: typeof isAddSubnetValidatorTx;
+declare const index_isAddValidatorTx: typeof isAddValidatorTx;
+declare const index_isBaseTx: typeof isBaseTx;
+declare const index_isBech32Address: typeof isBech32Address;
+declare const index_isCreateChainTx: typeof isCreateChainTx;
+declare const index_isCreateSubnetTx: typeof isCreateSubnetTx;
+declare const index_isExportTx: typeof isExportTx;
+declare const index_isImportTx: typeof isImportTx;
+declare const index_isObsidianApp: typeof isObsidianApp;
+declare const index_isRemoveSubnetValidatorTx: typeof isRemoveSubnetValidatorTx;
+declare const index_isTransferSubnetOwnershipTx: typeof isTransferSubnetOwnershipTx;
+declare const index_isTransformSubnetTx: typeof isTransformSubnetTx;
+declare const index_parseAvalancheTx: typeof parseAvalancheTx;
+declare const index_populateCredential: typeof populateCredential;
+declare const index_signedTxToHex: typeof signedTxToHex;
+declare const index_sortUTXOsByAmount: typeof sortUTXOsByAmount;
+declare const index_sortUTXOsByAmountAscending: typeof sortUTXOsByAmountAscending;
+declare const index_sortUTXOsByAmountDescending: typeof sortUTXOsByAmountDescending;
+declare const index_sortUTXOsStaking: typeof sortUTXOsStaking;
+declare const index_verifyDerivationPath: typeof verifyDerivationPath;
+declare namespace index {
+  export {
+    index_AbstractProvider as AbstractProvider,
+    index_AddDelegatorTx as AddDelegatorTx,
+    index_AddPermissionlessDelegatorTx as AddPermissionlessDelegatorTx,
+    index_AddPermissionlessValidatorTx as AddPermissionlessValidatorTx,
+    index_AddSubnetValidatorTx as AddSubnetValidatorTx,
+    index_AddValidatorTx as AddValidatorTx,
+    index_AddressWallet as AddressWallet,
+    index_BaseTx as BaseTx,
+    index_ChainIDAlias as ChainIDAlias,
+    index_CreateChainTx as CreateChainTx,
+    index_CreateSubnetTx as CreateSubnetTx,
+    index_ExportTx as ExportTx,
+    index_FeeData as FeeData,
+    index_FujiContext as FujiContext,
+    index_GetAvaxBalanceDict as GetAvaxBalanceDict,
+    index_GetStakedAvaxBalanceDict as GetStakedAvaxBalanceDict,
+    index_GlacierOutput as GlacierOutput,
+    index_ImportTx as ImportTx,
+    index_JsonRpcProvider as JsonRpcProvider,
+    index_LedgerGetXpubResponse as LedgerGetXpubResponse,
+    index_LedgerSigner as LedgerSigner,
+    index_LedgerWallet as LedgerWallet,
+    index_MainnetContext as MainnetContext,
+    index_MnemonicWallet as MnemonicWallet,
+    index_MnemonicWalletVoid as MnemonicWalletVoid,
+    index_P_CHAIN_TX_SIZE_LIMIT as P_CHAIN_TX_SIZE_LIMIT,
+    index_RemoveSubnetValidatorTx as RemoveSubnetValidatorTx,
+    index_SignMessageRequest as SignMessageRequest,
+    index_SignTxBufferRequest as SignTxBufferRequest,
+    index_SignTxRequest as SignTxRequest,
+    index_Signer as Signer,
+    index_SimpleLedgerSigner as SimpleLedgerSigner,
+    index_SimpleSigner as SimpleSigner,
+    index_SizeSupportedTx as SizeSupportedTx,
+    index_StaticSigner as StaticSigner,
+    index_TransferSubnetOwnershipTx as TransferSubnetOwnershipTx,
+    index_TransformSubnetTx as TransformSubnetTx,
+    index_Tx as Tx,
+    index_TxBase as TxBase,
+    index_TxType as TxType,
+    index_UnknownTx as UnknownTx,
+    index_UtxoInfo as UtxoInfo,
+    index_WalletAbstract as WalletAbstract,
+    index_WalletVoid as WalletVoid,
+    index_addSignaturesToAvalancheTx as addSignaturesToAvalancheTx,
+    index_convertGlacierUtxo as convertGlacierUtxo,
+    index_createAvalancheEvmUnsignedTx as createAvalancheEvmUnsignedTx,
+    index_createAvalancheUnsignedTx as createAvalancheUnsignedTx,
+    index_digestMessage as digestMessage,
+    index_emptySignature as emptySignature,
+    index_getAddressFromXpub as getAddressFromXpub,
+    index_getAddressPublicKeyFromXpub as getAddressPublicKeyFromXpub,
+    index_getAssetBalance as getAssetBalance,
+    index_getLedgerProvider as getLedgerProvider,
+    index_getMaximumUtxoSet as getMaximumUtxoSet,
+    index_getPaginatedUTXOs as getPaginatedUTXOs,
+    index_getPchainUnixNow as getPchainUnixNow,
+    index_getStakeForAddresses as getStakeForAddresses,
+    index_getStakedAssetBalance as getStakedAssetBalance,
+    index_getUTXOsForAddresses as getUTXOsForAddresses,
+    index_getUnixNow as getUnixNow,
+    index_getUtxoInfo as getUtxoInfo,
+    index_getUtxosByTxFromGlacier as getUtxosByTxFromGlacier,
+    index_getVmByChainAlias as getVmByChainAlias,
+    index_getXpubFromMnemonic as getXpubFromMnemonic,
+    index_isAddDelegatorTx as isAddDelegatorTx,
+    index_isAddPermissionlessDelegatorTx as isAddPermissionlessDelegatorTx,
+    index_isAddPermissionlessValidatorTx as isAddPermissionlessValidatorTx,
+    index_isAddSubnetValidatorTx as isAddSubnetValidatorTx,
+    index_isAddValidatorTx as isAddValidatorTx,
+    index_isBaseTx as isBaseTx,
+    index_isBech32Address as isBech32Address,
+    index_isCreateChainTx as isCreateChainTx,
+    index_isCreateSubnetTx as isCreateSubnetTx,
+    index_isExportTx as isExportTx,
+    index_isImportTx as isImportTx,
+    index_isObsidianApp as isObsidianApp,
+    index_isRemoveSubnetValidatorTx as isRemoveSubnetValidatorTx,
+    index_isTransferSubnetOwnershipTx as isTransferSubnetOwnershipTx,
+    index_isTransformSubnetTx as isTransformSubnetTx,
+    index_parseAvalancheTx as parseAvalancheTx,
+    index_populateCredential as populateCredential,
+    index_signedTxToHex as signedTxToHex,
+    index_sortUTXOsByAmount as sortUTXOsByAmount,
+    index_sortUTXOsByAmountAscending as sortUTXOsByAmountAscending,
+    index_sortUTXOsByAmountDescending as sortUTXOsByAmountDescending,
+    index_sortUTXOsStaking as sortUTXOsStaking,
+    index_verifyDerivationPath as verifyDerivationPath,
+  };
+}
+
+/**
+ * Get the derivation path used by wallet addresses
+ * @param addressIndex Which index is the address on
+ * @param pathSpec BIP44 vs LedgerLive
+ * @param vm Which VM is this address on. Coin index changes between Avalanche and EVM
+ */
+declare function getAddressDerivationPath(addressIndex: number, pathSpec: DerivationPath, vm: 'EVM' | 'AVM' | 'PVM'): string;
+
+/**
+ * Get the public key from a given private key.
+ * @param {(string | Buffer)} privateKey - The string or (hex encoded) byte sequence representation of the private key
+ * @throws Will throw an error for invalid private keys
+ */
+declare function getPublicKeyFromPrivateKey(privateKey: string | Buffer): Buffer;
+
+declare function getPubKeyFromTransport(t: Transport, accountIndex: number, pathType: DerivationPath, vm?: VM): Promise<Buffer>;
+
+/**
+ * Returns an extended public key for address derivation.
+ * @remarks Returns the extended public key for the given `path` (`m/44'/60'/0'` by default). This key can be used to derive addresses.
+ * @param transport
+ * @param display
+ * @param path
+ */
+declare function getLedgerExtendedPublicKey(transport: Transport, display?: boolean, path?: string): Promise<string>;
+
+declare function omitUndefinedKeys(object: Record<string, any>): Record<string, any>;
+
+/**
+ * Get application name and version.
+ * @see https://developers.ledger.com/docs/transport/open-close-info-on-apps/#get-information
+ * @param transport
+ */
+declare function getLedgerAppInfo(transport: Transport): Promise<{
+    applicationName: string;
+    version: string;
+}>;
+
+/**
+ * Open a given application on the connected Hardware Wallet, based on its ASCII name. If successfully processed, it triggers a specific display on the product’s screen, asking the user for a confirmation before actually opening the application.
+ * @see https://developers.ledger.com/docs/transport/open-close-info-on-apps/#open-application
+ */
+declare function openLedgerApp(transport: Transport, applicationName: string): Promise<boolean>;
+
+/**
+ * Quit the current ledger app.
+ * @see https://developers.ledger.com/docs/transport/open-close-info-on-apps/#quit-application
+ * @param transport
+ */
+declare function quitLedgerApp(transport: Transport): Promise<Buffer>;
+
+export { index as Avalanche, BitcoinHistoryTx, BitcoinInputUTXO, BitcoinInputUTXOWithOptionalScript, BitcoinLedgerInputUTXO, BitcoinLedgerWallet, BitcoinOutputUTXO, BitcoinProvider, BitcoinProviderAbstract, BitcoinTx, BitcoinWallet, BitcoinWalletAbstract, BitcoinWalletVoid, DerivationPath, ETH_ACCOUNT_PATH, ETH_COIN_PATH, JsonRpcBatchInternal, LedgerSigner$1 as LedgerSigner, addEncodedSigToPsbt, createPSBTV2, createPsbt, createTransferTx, createWalletPolicy, formatAddressForNetworkBech32, getAddressDerivationPath, getAddressFromXPub, getAddressPrivateKeyFromXPriv, getAddressPublicKeyFromXPub, getAppEth, getBech32Address, getBech32AddressFromXPub, getBtcAddressFromPubKey, getEvmAddressFromPubKey, getLedgerAppInfo, getLedgerExtendedPublicKey, getMaxTransferAmount, getPubKeyFromTransport, getPublicKeyFromPrivateKey, getTransferTxDetails, getVoidSigner, getWalletFromMnemonic, getXpubFromMnemonic$1 as getXpubFromMnemonic, isERC20Transfer, isNativeTxn, omitUndefinedKeys, onBalanceChange, openLedgerApp, psbt2ToPsbt0, quitLedgerApp, selectUtxos };