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

package/esm/Avalanche/wallets/WalletAbstract.d.ts

@@ -0,0 +1,131 @@
+import * as _avalabs_avalanchejs from '@avalabs/avalanchejs';
+import { utils, pvm, Common } from '@avalabs/avalanchejs';
+import { AbstractProvider } from '../providers/AbstractProvider.js';
+import { ChainIDAlias } from '../models.js';
+
+/**
+ * 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);
+}
+
+export { WalletAbstract };

package/esm/Avalanche/wallets/WalletAbstract.js

@@ -0,0 +1 @@
+import{TransferableOutput as e,avm as t,pvm as s,evm as r,networkIDs as i,utils as d}from"@avalabs/avalanchejs";import"../utils/populateCredential.js";import{strip0x as o}from"@avalabs/core-utils-sdk";import"ethers";import"../providers/constants.js";import"@avalabs/chains-sdk";import"create-hash";import"bip32";import{getUTXOsForAddresses as n}from"../utils/getAllUTXOs.js";import{getStakeForAddresses as a}from"../utils/getStakeForAddresses.js";import"@avalabs/glacier-sdk";import"bip39";import"xss";import{sortUTXOsByAmount as g,sortUTXOsStaking as h,sortUTXOsByAmountAscending as p}from"../utils/sortUTXOs.js";import"bip32-path";const{parse:c,hexToBuffer:m}=d;class A{constructor(e){this.provider=e}setProvider(e){this.provider=e}getProvider(){return this.provider}async getUTXOs(e){const t=this.provider.getApi(e);return n(this.getAddresses(e),t)}async getStake(){const e=this.provider.getApiP();return a(this.getAddresses("P"),e)}async getAtomicUTXOs(e,t){if(e===t)throw new Error("Chain can not be the same as source chain.");const s=this.provider.getApi(e),r=this.provider.getChainID(t);return n(this.getAddresses(e),s,{sourceChain:r,addresses:[]})}exportX(s,r,i,d){d=d||this.getCurrentAddress(i);const o=c(d)[2],n=this.provider.getAvaxID(),a=e.fromNative(n,s,[o]),h=g(r.getUTXOs(),!0),p=this.provider.getChainID(i),m=this.getAddresses("X").map((e=>c(e)[2])),A=c(this.getChangeAddress("X"))[2];return t.newExportTx(this.provider.getContext(),p,m,h,[a],{threshold:1,changeAddresses:[A]})}importP(e,t,r){const i=this.provider.getChainID(t),d=this.getAddresses("P").map((e=>c(e)[2])),o=c(this.getChangeAddress("P"))[2];r=r||this.getCurrentAddress("P");const n=c(r)[2];return s.newImportTx(this.provider.getContext(),i,e.getUTXOs(),[n],d,{changeAddresses:[o]})}importX(e,s,r){const i=this.provider.getChainID(s),d=this.getAddresses("X").map((e=>c(e)[2])),o=c(this.getChangeAddress("X"))[2];r=r||this.getCurrentAddress("X");const n=c(r)[2];return t.newImportTx(this.provider.getContext(),i,e.getUTXOs(),[n],d,{changeAddresses:[o]})}importC(e,t,s,i,d){const n=this.provider.getChainID(t),a=this.getAddresses("C").map((e=>c(e)[2]));d=d||this.getAddressEVM();const g=Buffer.from(o(d),"hex");return r.newImportTxFromBaseFee(this.provider.getContext(),g,a,e.getUTXOs(),n,s,i)}exportC(e,t,s,i,d){const o=m(this.getAddressEVM()),n=this.provider.getChainID(t);d=d||this.getCurrentAddress(t);const a=c(d)[2],g=i/BigInt(1e9);return r.newExportTxFromBaseFee(this.provider.getContext(),g,e,n,o,[a],s)}async getNonce(){const e=this.getAddressEVM();return await this.provider.evmRpc.getTransactionCount(e)}exportP(t,r,i,d){d=d||this.getCurrentAddress(i);const o=c(d)[2],n=this.provider.getAvaxID(),a=e.fromNative(n,t,[o]),h=g(r.getUTXOs(),!0),p=this.provider.getChainID(i),m=this.getAddresses("P").map((e=>c(e)[2])),A=c(this.getChangeAddress("P"))[2];return s.newExportTx(this.provider.getContext(),p,m,h,[a],{changeAddresses:[A]})}addValidator(e,t,r,i,d,o,n){const a=h(e.getUTXOs()),g=this.getAddresses("P").map((e=>c(e)[2])),p=n?.rewardAddress||this.getCurrentAddress("P"),m=c(p)[2],A=c(this.getChangeAddress("P"))[2];return s.newAddValidatorTx(this.provider.getContext(),a,g,t,i,d,r,[m],o,{changeAddresses:[A]})}addDelegator(e,t,r,i,d,o){const n=h(e.getUTXOs()),a=this.getAddresses("P").map((e=>c(e)[2])),g=o?.rewardAddress||this.getCurrentAddress("P"),p=c(g)[2],m=c(this.getChangeAddress("P"))[2];return s.newAddDelegatorTx(this.provider.getContext(),n,a,t,i,d,r,[p],{changeAddresses:[m]})}consolidateP(t,r,i,d){const o=p(t.getUTXOs());i=i??this.getCurrentAddress("P");const n=c(i)[2],a=this.provider.getContext(),g=[e.fromNative(a.avaxAssetID,r,[n])],h=this.getAddresses("P").map((e=>c(e)[2]));return s.newBaseTx(this.provider.getContext(),h,o,g,d)}baseTX(r,i,d,o,n,a){const[h,p,m]=c(d);if(h!==i||p!==this.provider.getHrp())throw new Error(`Invalid recipient address "${d}"`);const A=Object.entries(o).map((([t,s])=>e.fromNative(t,s,[m]))),v=g(r.getUTXOs(),!0),u=(a??this.getAddresses(i)).map((e=>c(e)[2]));return"X"===i?t.newBaseTx(this.provider.getContext(),u,v,A,n):s.newBaseTx(this.provider.getContext(),u,v,A,n)}createBlockchain(e,t,r,i,d,o,n,a,h){const p=g(e.getUTXOs(),!0),m=(h??this.getAddresses("P")).map((e=>c(e)[2]));return s.newCreateBlockchainTx(this.provider.getContext(),p,m,t,r,i,d,o,n,a)}createSubnet(e,t,r,i,d,o){const n=g(e.getUTXOs(),!0),a=(r??this.getAddresses("P")).map((e=>c(e)[2])),h=t.map((e=>c(e)[2]));return s.newCreateSubnetTx(this.provider.getContext(),n,a,h,i,d??1,o??BigInt(0))}addSubnetValidator(e,t,r,i,d,o,n,a,h){const p=g(e.getUTXOs(),!0),m=(a??this.getAddresses("P")).map((e=>c(e)[2]));return s.newAddSubnetValidatorTx(this.provider.getContext(),p,m,t,r,i,d,o,n,h)}addPermissionlessValidator(e,t,r,d,o,n,a,g,p,m,A,v,u){const C=h(e.getUTXOs()),x=(g??this.getAddresses("P")).map((e=>c(e)[2])),T=(p??[this.getCurrentAddress("P")]).map((e=>c(e)[2])),l=(m??[this.getCurrentAddress("P")]).map((e=>c(e)[2]));if(!(n!==i.PrimaryNetworkID.toString()||A&&v))throw new Error("Must provide public key and signature for primary subnet.");const P={changeAddresses:[c(this.getChangeAddress("P"))[2]],...u??{}};return s.newAddPermissionlessValidatorTx(this.provider.getContext(),C,x,t,n,r,d,o,T,l,a,P,void 0,void 0,A,v)}addPermissionlessDelegator(e,t,r,i,d,o,n,a,g){const p=h(e.getUTXOs()),m=(n??this.getAddresses("P")).map((e=>c(e)[2])),A=(a??[this.getCurrentAddress("P")]).map((e=>c(e)[2])),v={changeAddresses:[c(this.getChangeAddress("P"))[2]],...g??{}};return s.newAddPermissionlessDelegatorTx(this.provider.getContext(),p,m,t,o,r,i,d,A,v,void 0,void 0)}removeSubnetValidator(e,t,r,i,d,o){const n=g(e.getUTXOs(),!0),a=(d??this.getAddresses("P")).map((e=>c(e)[2]));return s.newRemoveSubnetValidatorTx(this.provider.getContext(),n,a,t,r,i,o)}transferSubnetOwnershipTx(e,t,r,i,d,o,n,a){const h=g(e.getUTXOs(),!0),p=(d??this.getAddresses("P")).map((e=>c(e)[2])),m=i.map((e=>c(e)[2]));return s.newTransferSubnetOwnershipTx(this.provider.getContext(),h,p,t,r,m,o,n??1,a??BigInt(0))}transformSubnetTx(e,t,r,i,d,o,n,a,h,p,m,A,v,u,C,x,T,l){const P=g(e.getUTXOs(),!0),w=(T??this.getAddresses("P")).map((e=>c(e)[2]));return s.newTransformSubnetTx(this.provider.getContext(),P,w,t,r,i,d,o,n,a,h,p,m,A,v,u,C,x,l)}}export{A as WalletAbstract};

package/esm/Avalanche/wallets/WalletVoid.d.ts

@@ -0,0 +1,40 @@
+import { WalletAbstract } from './WalletAbstract.js';
+import { AbstractProvider } from '../providers/AbstractProvider.js';
+import { ChainIDAlias } from '../models.js';
+
+/**
+ * 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;
+}
+
+export { WalletVoid };

package/esm/Avalanche/wallets/WalletVoid.js

@@ -0,0 +1 @@
+import{WalletAbstract as e}from"./WalletAbstract.js";import{fromSeed as r}from"bip32";import{validateMnemonic as t,mnemonicToSeedSync as s}from"bip39";import{strip0x as i}from"@avalabs/core-utils-sdk";import"@avalabs/avalanchejs";import"../utils/populateCredential.js";import{SigningKey as o,computeAddress as a}from"ethers";import"../providers/constants.js";import"@avalabs/chains-sdk";import"create-hash";import"@avalabs/glacier-sdk";import"xss";import{verifyDerivationPath as p}from"../utils/verifyDerivationPath.js";class n extends e{constructor(e,r,t){if(super(t),this.pubkeyXP=e,this.pubkeyC=r,33!==r.length||33!==e.length)throw new Error("Public key must be 33 byte compressed public key")}static fromPublicKey(e,r,t){const s=i(o.computePublicKey(e,!0)),a=i(o.computePublicKey(r,!0)),p=Buffer.from(s,"hex"),u=Buffer.from(a,"hex");return new n(p,u,t)}static fromMnemonic(e,i,o,a){if(!t(e))throw new Error("Invalid mnemonic phrase.");if(!p(o)||!p(i))throw new Error("Not valid derivation path. Make sure it is a valid BIP44 path starting with m/");const u=s(e),d=r(u),m=d.derivePath(o),h=d.derivePath(i);return n.fromPublicKey(h.publicKey,m.publicKey,a)}getAddress(e){const r="C"===e?this.pubkeyC:this.pubkeyXP;return this.provider.getAddress(r,e)}getAddressEVM(){return a(`0x${this.pubkeyC.toString("hex")}`)}getAddresses(e){return[this.getAddress(e)]}getChangeAddress(e){return this.getAddress(e)}getCurrentAddress(e){return this.getAddress(e)}}export{n as WalletVoid};

package/esm/Avalanche/wallets/ledger/LedgerSigner.d.ts

@@ -0,0 +1,49 @@
+import { WalletVoid } from '../WalletVoid.js';
+import { Signer, SignMessageRequest, SignTxRequest, SignTxBufferRequest } from '../models.js';
+import { AbstractProvider } from '../../providers/AbstractProvider.js';
+import { UnsignedTx } from '@avalabs/avalanchejs';
+import Transport from '@ledgerhq/hw-transport';
+import { ChainIDAlias } from '../../models.js';
+
+/**
+ * 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[]>;
+}
+
+export { LedgerSigner };

package/esm/Avalanche/wallets/ledger/LedgerSigner.js

@@ -0,0 +1 @@
+import{WalletVoid as r}from"../WalletVoid.js";import{isObsidianApp as t}from"./isObsidianApp.js";import{ZondaxProvider as e}from"./ZondaxProvider.js";import i from"bip32-path";import o from"@ledgerhq/hw-app-eth";import{utils as a}from"@avalabs/avalanchejs";import"../../utils/populateCredential.js";import"@avalabs/core-utils-sdk";import{SigningKey as s}from"ethers";import"../../providers/constants.js";import"@avalabs/chains-sdk";import"create-hash";import"bip32";import"@avalabs/glacier-sdk";import"bip39";import"xss";import{verifyDerivationPath as n}from"../../utils/verifyDerivationPath.js";const{strip0x:p}=a;class f extends r{constructor(r,t,e,i,o){const p=a.strip0x(s.computePublicKey(r,!0)),f=a.strip0x(s.computePublicKey(e,!0));if(super(Buffer.from(p,"hex"),Buffer.from(f,"hex"),o),this.pathXP=t,this.pathC=i,!n(t)||!n(i))throw new Error("Invalid path configuration.")}static async fromTransport(r,e,i,a){if(await t(r))throw new Error("Ledger app not supported. Must be version >= 0.6.0");if(!n(e)||!n(i))throw new Error("Invalid path configuration.");const h=new o(r),u=await h.getAddress(i,!1),c=await h.getAddress(e,!1),m=Buffer.from(p(u.publicKey),"hex"),l=Buffer.from(p(c.publicKey),"hex"),g=Buffer.from(p(s.computePublicKey(m,!0)),"hex"),d=Buffer.from(p(s.computePublicKey(l,!0)),"hex");return new f(d,e,g,i,a)}async signMessage(r){throw new Error("not implemented")}getFullSignerPath(r){return"C"===r?this.pathC:this.pathXP}getPartialSignerPath(r){return this.getFullSignerPath(r).split("/").slice(4).join("/")}getAccountPath(r){return this.getFullSignerPath(r).split("/").slice(0,4).join("/")}async signTx(r){if(!r.transport)throw new Error("Ledger transport not provided");const t=r.tx,e=t.getVM(),i=Buffer.from(t.toBytes()),o="EVM"===e?"C":"X";return(await this.signTxBuffer({buffer:i,chain:o,transport:r.transport})).forEach((r=>{t.addSignature(r)})),t}async signTxBuffer(r){if(!r.transport)throw new Error("Ledger transport not provided");const t=i.fromString(this.getAccountPath(r.chain)),o=i.fromString(this.getPartialSignerPath(r.chain));return[...(await e.signTx(r.transport,r.buffer,t,[o],[o])).signatures.values()]}}export{f as LedgerSigner};

package/esm/Avalanche/wallets/ledger/SimpleLedgerSigner.d.ts

@@ -0,0 +1,32 @@
+import { UnsignedTx } from '@avalabs/avalanchejs';
+import { Signer, SignTxRequest, SignTxBufferRequest, SignMessageRequest } from '../models.js';
+import { JsonRpcProvider } from '../../providers/JsonRpcProvider.js';
+
+/**
+ * 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>;
+}
+
+export { SimpleLedgerSigner };

package/esm/Avalanche/wallets/ledger/SimpleLedgerSigner.js

@@ -0,0 +1 @@
+import{EVMUnsignedTx as t,UnsignedTx as r,utils as e}from"@avalabs/avalanchejs";import s from"bip32-path";import{getTxOutputAddresses as i}from"../../utils/getTxOutputAddresses.js";import{ZondaxProvider as n}from"./ZondaxProvider.js";import{fromBase58 as o}from"bip32";import"../../utils/populateCredential.js";import"@avalabs/core-utils-sdk";import"ethers";import"../../providers/constants.js";import"@avalabs/chains-sdk";import{digestMessage as a}from"../../utils/digestMessage.js";import"@avalabs/glacier-sdk";import"bip39";import"xss";const{parse:c}=e;class h{constructor(t,r,e){this.activeAccountIndex=t,this.provider=r,e&&(this.accountNode=o(e))}accountNode;reSerializeTx(e,s){return e instanceof t||"C"===s?t.fromJSON(JSON.stringify(e.toJSON())):r.fromJSON(JSON.stringify(e.toJSON()))}getChainAlias(t){return"EVM"===t.getVM()?"C":"X"}getAccountPath(t){switch(t){case"X":case"P":return"m/44'/9000'/0'";case"C":return"m/44'/60'/0'"}}getAddressOfPath(t,r){if(!this.accountNode)return null;const{publicKey:e}=this.accountNode.derivePath(t),s=this.provider.getAddress(e,r);return Buffer.from(c(s)[2]).toString("hex")}getAddressPathMap(t){const{tx:r,externalIndices:e,internalIndices:s}=t,i=this.getChainAlias(r),n=`0/${this.activeAccountIndex}`,o=new Map;if("C"===i||!this.accountNode)return o;const a=[n,...(e??[]).map((t=>`0/${t}`)),...(s??[]).map((t=>`1/${t}`))];for(const t of a){const r=this.getAddressOfPath(t,i);r&&o.set(r,t)}return o}getAddressBipPaths(t,r){return 0===r.size?[s.fromString(`0/${this.activeAccountIndex}`)]:t.reduce(((t,e)=>{const i=r.get(Buffer.from(e).toString("hex"));return i&&t.push(s.fromString(i)),t}),[])}async signTx(t){if(!t.transport)throw new Error("Ledger transport not provided");const r=this.getChainAlias(t.tx),e=this.reSerializeTx(t.tx,r),s=Buffer.from(e.toBytes()),n=this.getAddressPathMap(t),o=this.getAddressBipPaths(e.getAddresses(),n),a=this.getAddressBipPaths([...i(e)],n);return(await this.signTxBuffer({buffer:s,chain:r,transport:t.transport,signers:o,change:a})).forEach((t=>{e.addSignature(t)})),e}async signTxBuffer(t){if(!t.transport)throw new Error("Ledger transport not provided");if(!t.signers)throw new Error("Signers not provided");const r=t.change||[],e=s.fromString(this.getAccountPath(t.chain));return[...(await n.signTx(t.transport,t.buffer,e,t.signers,r)).signatures.values()]}async signMessage(t){if(!t.transport||!t.message)throw new Error("Unable to sign message. Incomplete or invalid request.");const r=t.signer||s.fromString(`0/${this.activeAccountIndex}`);if(2!=r.toPathArray().length)throw new Error("Given signer path must have a depth of 2. Ex. 0/0, 0/1");const e=a(t.message),i=(await n.signHash(t.transport,e,s.fromString(this.getAccountPath(t.chain)),[r])).signatures.get(r.toString(!0));if(!i)throw new Error("Failed to sign message.");return i}}export{h as SimpleLedgerSigner};

package/esm/Avalanche/wallets/ledger/ZondaxProvider.js

@@ -0,0 +1 @@
+import t from"@avalabs/hw-app-avalanche";const e={type:"zondax",getApp:e=>new t(e),async getVersion(t){const e=this.getApp(t);return(await e.getAppInfo()).appVersion},async getAddress(t,e,n={show:!1,hrp:"avax"}){const a=this.getApp(t);return{publicKey:(await a.getAddressAndPubKey(e.toString(),n.show,n.hrp)).publicKey}},async getXPUB(t,e){const n=this.getApp(t),a=await n.getExtendedPubKey(e,!1);return{pubKey:a.publicKey,chainCode:a.chain_code}},async signHash(t,e,n,a){const s=this.getApp(t),i=a.map((t=>t.toString(!0))),p=await s.signHash(n.toString(),i,e),r=p.signatures||new Map;return{hash:p.hash||Buffer.from(""),signatures:r}},async signTx(t,e,n,a,s){const i=this.getApp(t),p=a.map((t=>t.toString(!0))),r=s?.map((t=>t.toString(!0)))||[],g=await i.sign(n.toString(),p,e,r),o=g.signatures||new Map;return{...g,signatures:o}}};export{e as ZondaxProvider};

package/esm/Avalanche/wallets/ledger/constants.js

@@ -0,0 +1 @@
+const o="0.6.0";export{o as ZONDAX_VERSION};

package/esm/Avalanche/wallets/ledger/getLedgerProvider.d.ts

@@ -0,0 +1,10 @@
+import { LedgerProvider } from './models.js';
+import Transport from '@ledgerhq/hw-transport';
+
+/**
+ * Get the correct ledger provider given a transport instance.
+ * @param t
+ */
+declare function getLedgerProvider(t: Transport): Promise<LedgerProvider>;
+
+export { getLedgerProvider };

package/esm/Avalanche/wallets/ledger/getLedgerProvider.js

@@ -0,0 +1 @@
+import{ZondaxProvider as r}from"./ZondaxProvider.js";async function o(o){return r}export{o as getLedgerProvider};

package/esm/Avalanche/wallets/ledger/isObsidianApp.d.ts

@@ -0,0 +1,5 @@
+import Transport from '@ledgerhq/hw-transport';
+
+declare function isObsidianApp(t: Transport): Promise<boolean>;
+
+export { isObsidianApp };

package/esm/Avalanche/wallets/ledger/isObsidianApp.js

@@ -0,0 +1 @@
+import{ZondaxProvider as o}from"./ZondaxProvider.js";import{ZONDAX_VERSION as r}from"./constants.js";async function t(t){return!(await o.getVersion(t)>=r)}export{t as isObsidianApp};

package/esm/Avalanche/wallets/ledger/models.d.ts

@@ -0,0 +1,37 @@
+import { Bip32Path } from 'bip32-path';
+import Transport from '@ledgerhq/hw-transport';
+import AppZondax, { ResponseBase } from '@avalabs/hw-app-avalanche';
+
+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';
+
+export { LedgerProvider, LedgerProviderType };

package/esm/Avalanche/wallets/legacy/LedgerWallet.d.ts

@@ -0,0 +1,41 @@
+import { MnemonicWalletVoid } from './MnemonicWalletVoid.js';
+import { Signer, SignMessageRequest, SignTxRequest, SignTxBufferRequest } from '../models.js';
+import Transport from '@ledgerhq/hw-transport';
+import { AbstractProvider } from '../../providers/AbstractProvider.js';
+import { UnsignedTx } from '@avalabs/avalanchejs';
+import { ChainIDAlias } from '../../models.js';
+
+/**
+ * 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[]>;
+}
+
+export { LedgerWallet };

package/esm/Avalanche/wallets/legacy/LedgerWallet.js

@@ -0,0 +1 @@
+import{MnemonicWalletVoid as r}from"./MnemonicWalletVoid.js";import{getAppEth as t}from"../../../EVM/utils/getAppEth.js";import{SigningKey as e}from"ethers";import{getAddressDerivationPath as s}from"../../../utils/getAddressDerivationPath.js";import{utils as o}from"@avalabs/avalanchejs";import"hdkey";import"buffer";import{DerivationPath as i}from"../../../EVM/constants.js";import"@openzeppelin/contracts/build/contracts/ERC20.json";import{fromPublicKey as n}from"bip32";import"bip39";import"bitcoinjs-lib";import{strip0x as a}from"@avalabs/core-utils-sdk";import"@ledgerhq/hw-transport";import"@metamask/eth-sig-util";import d from"bip32-path";import{isObsidianApp as p}from"../ledger/isObsidianApp.js";import{ZondaxProvider as f}from"../ledger/ZondaxProvider.js";import{getTxOutputAddresses as m}from"../../utils/getTxOutputAddresses.js";const{parse:c}=o;class g extends r{constructor(r,t,e){super(r,t,e)}getAdditionalAddressesByIndices(r,t,e){return"C"===e?[]:r.map((r=>{const s=this.getAddressAtIndex(r,t,e),[,,o]=c(s);return Buffer.from(o).toString("hex")}))}static async fromTransport(r,o){if(await p(r))throw new Error("Unsupported ledger app version. Must be >= 0.6.0");const d=t(r),m=await f.getXPUB(r,g.getAccountPath("X")),c=n(m.pubKey,m.chainCode),u=s(0,i.BIP44,"EVM"),h=await d.getAddress(u,!1),l=e.computePublicKey(Buffer.from(h.publicKey,"hex"),!0),w=Buffer.from(a(l),"hex");return new g(c.toBase58(),w,o)}static getAccountPath(r){switch(r){case"P":case"X":return"m/44'/9000'/0'";case"C":return"m/44'/60'/0'"}}async signMessage(r){throw new Error("not implemented")}filterOwnedAddresses(r,t,e){const s=this.getInternalRawAddresses().map((r=>r.toString("hex"))),o=this.getExternalRawAddresses().map((r=>r.toString("hex"))),i=new Set([...s,...e??[]]),n=new Set([...o,...t??[]]),a=new Set;return r.forEach((r=>{const t=r.toString("hex");if(i.has(t)){const r=[...i].indexOf(t);a.add(`1/${r}`)}else if(n.has(t)){const r=[...n].indexOf(t);a.add(`0/${r}`)}})),a}async signTx(r){if(!r.transport)throw new Error("Ledger transport not provided");const{tx:t,externalIndices:e,internalIndices:s}=r,o=t.getVM(),i=Buffer.from(t.toBytes()),n="EVM"===o?"C":"X",a=t.getAddresses().map((r=>Buffer.from(r))),p=this.getAdditionalAddressesByIndices(e??[],!1,n),f=this.getAdditionalAddressesByIndices(s??[],!0,n),c=[...this.filterOwnedAddresses(a,p,f).values()].map((r=>d.fromString(r))),g=[...m(t)].map((r=>Buffer.from(r))),u=[...this.filterOwnedAddresses(g).values()].map((r=>d.fromString(r)));return(await this.signTxBuffer({buffer:i,chain:n,transport:r.transport,signers:c,change:u})).forEach((r=>{t.addSignature(r)})),t}async signTxBuffer(r){if(!r.transport)throw new Error("Ledger transport not provided");if(!r.signers)throw new Error("Signers not provided");const t=r.change||[],e=d.fromString(g.getAccountPath(r.chain));return[...(await f.signTx(r.transport,r.buffer,e,r.signers,t)).signatures.values()]}}export{g as LedgerWallet};

package/esm/Avalanche/wallets/legacy/MnemonicWallet.d.ts

@@ -0,0 +1,30 @@
+import { MnemonicWalletVoid } from './MnemonicWalletVoid.js';
+import { Signer, SignTxRequest, SignTxBufferRequest, SignMessageRequest } from '../models.js';
+import { AbstractProvider } from '../../providers/AbstractProvider.js';
+import { UnsignedTx } from '@avalabs/avalanchejs';
+import { BIP32Interface } from 'bip32';
+
+/**
+ * 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>;
+}
+
+export { MnemonicWallet };

package/esm/Avalanche/wallets/legacy/MnemonicWallet.js

@@ -0,0 +1 @@
+import{MnemonicWalletVoid as e}from"./MnemonicWalletVoid.js";import{addTxSignatures as t,utils as r}from"@avalabs/avalanchejs";import{validateMnemonic as i,mnemonicToSeedSync as n}from"bip39";import{fromBase58 as o,fromSeed as s}from"bip32";import"@ledgerhq/hw-app-eth";import{SigningKey as a}from"ethers";import{getAddressDerivationPath as p}from"../../../utils/getAddressDerivationPath.js";import"hdkey";import"buffer";import{DerivationPath as c}from"../../../EVM/constants.js";import"@openzeppelin/contracts/build/contracts/ERC20.json";import"bitcoinjs-lib";import"@avalabs/core-utils-sdk";import"@ledgerhq/hw-transport";import"@metamask/eth-sig-util";const{strip0x:h}=r;class m extends e{constructor(e,t,r){const i=o(e).neutered(),n=new a(t),s=Buffer.from(h(n.compressedPublicKey),"hex");super(i.toBase58(),s,r),this.evmPrivKey=t,this.accountNode=o(e)}accountNode;static fromMnemonic(e,t){if(!i(e))throw new Error("Invalid mnemonic phrase.");const r=n(e),o=s(r),a=o.derivePath("m/44'/9000'/0'"),h=o.derivePath(p(0,c.BIP44,"EVM"));if(!h.privateKey)throw new Error("Unable to derive EVM private key.");return new m(a.toBase58(),h.privateKey,t)}async signTx(e){const r=this.getSigningKeys(e);return await t({unsignedTx:e.tx,privateKeys:r}),e.tx}getExternalPrivateKeys(e){const t=[];for(let e=0;e<=this.externalIndex;e++){const r=this.accountNode.derivePath(`0/${e}`);if(!r.privateKey)throw new Error("Unable to get private key.");t.push(r.privateKey)}const r=(e??[]).reduce(((e,t)=>{if(t>this.externalIndex){const r=this.accountNode.derivePath(`0/${t}`);if(!r.privateKey)throw new Error("Unable to get private key.");e.push(r.privateKey)}return e}),[]);return[...t,...r]}getInternalPrivateKeys(e){const t=[];for(let e=0;e<=this.internalIndex;e++){const r=this.accountNode.derivePath(`1/${e}`);if(!r.privateKey)throw new Error("Unable to get private key.");t.push(r.privateKey)}const r=(e??[]).reduce(((e,t)=>{if(t>this.internalIndex){const r=this.accountNode.derivePath(`1/${t}`);if(!r.privateKey)throw new Error("Unable to get private key.");e.push(r.privateKey)}return e}),[]);return[...t,...r]}getSigningKeys(e){const{tx:t,externalIndices:r,internalIndices:i}=e,n=t.getVM();return"AVM"===n?[...this.getInternalPrivateKeys(i),...this.getExternalPrivateKeys(r)]:"PVM"===n?this.getExternalPrivateKeys(r):[this.evmPrivKey]}async signTxBuffer(e){throw new Error("not implemented")}async signMessage(e){throw new Error("not implemented")}}export{m as MnemonicWallet};

package/esm/Avalanche/wallets/legacy/MnemonicWalletVoid.d.ts

@@ -0,0 +1,83 @@
+import { BIP32Interface } from 'bip32';
+import { WalletAbstract } from '../WalletAbstract.js';
+import { AbstractProvider } from '../../providers/AbstractProvider.js';
+import { ChainIDAlias } from '../../models.js';
+
+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;
+}
+
+export { MnemonicWalletVoid };

package/esm/Avalanche/wallets/legacy/MnemonicWalletVoid.js

@@ -0,0 +1 @@
+import{fromBase58 as e,fromSeed as t}from"bip32";import{validateMnemonic as r,mnemonicToSeedSync as s}from"bip39";import{WalletVoid as n}from"../WalletVoid.js";import{WalletAbstract as d}from"../WalletAbstract.js";import"@ledgerhq/hw-app-eth";import"ethers";import{getAddressDerivationPath as i}from"../../../utils/getAddressDerivationPath.js";import{utils as a}from"@avalabs/avalanchejs";import"hdkey";import"buffer";import{DerivationPath as o}from"../../../EVM/constants.js";import"@openzeppelin/contracts/build/contracts/ERC20.json";import"bitcoinjs-lib";import"@avalabs/core-utils-sdk";import"@ledgerhq/hw-transport";import"@metamask/eth-sig-util";const{parse:h}=a;class l extends d{constructor(t,r,s){super(s),this.avmXpub=t,this.accountNode=e(t),this.evmWallet=new n(r,r,s)}accountNode;evmWallet;externalIndex=0;internalIndex=0;pubkeyCache={};static fromMnemonic(e,n){if(!r(e))throw new Error("Invalid mnemonic phrase.");const d=s(e),a=t(d),h=a.derivePath("m/44'/9000'/0'").neutered(),m=a.derivePath(i(0,o.BIP44,"EVM")).neutered();return new l(h.toBase58(),m.publicKey,n)}setExternalIndex(e){if(e<0)throw new Error("Index must be >= 0");this.externalIndex=e}setInternalIndex(e){if(e<0)throw new Error("Index must be >= 0");this.internalIndex=e}getPubKeyAtIndex(e,t=!1){if(e<0)throw new Error("Index must be >= 0");const r=`${t?1:0}/${e}`,s=this.pubkeyCache[r];if(s)return s;const{publicKey:n}=this.accountNode.derivePath(r);return this.pubkeyCache[r]=n,n}getAddressAtIndex(e,t=!1,r){const s=this.getPubKeyAtIndex(e,t);return this.provider.getAddress(s,r)}getExternalAddresses(e){const t=[];for(let r=0;r<=this.externalIndex;r++)t.push(this.getAddressAtIndex(r,!1,e));return t}getInternalAddresses(e){const t=[];for(let r=0;r<=this.internalIndex;r++)t.push(this.getAddressAtIndex(r,!0,e));return t}getAddresses(e){return"C"===e?[this.getCurrentAddress("C")]:"P"===e?[...this.getExternalAddresses(e)]:[...this.getInternalAddresses(e),...this.getExternalAddresses(e)]}getChangeAddress(e){return"C"===e?this.evmWallet.getAddress("C"):"P"===e?this.getAddressAtIndex(this.externalIndex,!1,"P"):this.getAddressAtIndex(this.internalIndex,!0,e)}getCurrentAddress(e){return"C"===e?this.evmWallet.getAddress("C"):this.getAddressAtIndex(this.externalIndex,!1,e)}incrementIndex(e){e?this.externalIndex++:this.internalIndex++}getAddressEVM(){return this.evmWallet.getAddressEVM()}getActiveIndices(){return{external:this.externalIndex,internal:this.internalIndex}}getInternalRawAddresses(){return this.getInternalAddresses("X").map((e=>Buffer.from(h(e)[2])))}getExternalRawAddresses(){return this.getExternalAddresses("X").map((e=>Buffer.from(h(e)[2])))}getRawAddressC(){return Buffer.from(h(this.getCurrentAddress("C"))[2])}}export{l as MnemonicWalletVoid};

package/esm/Avalanche/wallets/models.d.ts

@@ -0,0 +1,35 @@
+import { UnsignedTx, EVMUnsignedTx } from '@avalabs/avalanchejs';
+import Transport from '@ledgerhq/hw-transport';
+import { ChainIDAlias } from '../models.js';
+import { Bip32Path } from 'bip32-path';
+
+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;
+}
+
+export { LedgerGetXpubResponse, SignMessageRequest, SignTxBufferRequest, SignTxRequest, Signer };