@avalabs/core-wallets-sdk 3.1.0-alpha.2 → 3.1.0-alpha.21

package/esm/Avalanche/providers/constants.d.ts

@@ -1,3 +1,4 @@
+import * as _avalabs_avalanchejs_dist_vms_pvm from '@avalabs/avalanchejs/dist/vms/pvm';
 import { Context } from '@avalabs/avalanchejs';
 
 /**
@@ -8,5 +9,23 @@ declare const MainnetContext: Context.Context;
  * Avalanche Fuji testnet context
  */
 declare const FujiContext: Context.Context;
+declare const DevnetContext: {
+    addPrimaryNetworkDelegatorFee: bigint;
+    addPrimaryNetworkValidatorFee: bigint;
+    addSubnetDelegatorFee: bigint;
+    addSubnetValidatorFee: bigint;
+    avaxAssetID: string;
+    baseTxFee: bigint;
+    cBlockchainID: string;
+    createAssetTxFee: bigint;
+    createBlockchainTxFee: bigint;
+    createSubnetTxFee: bigint;
+    hrp: string;
+    networkID: number;
+    pBlockchainID: string;
+    transformSubnetTxFee: bigint;
+    xBlockchainID: string;
+    platformFeeConfig: _avalabs_avalanchejs_dist_vms_pvm.FeeConfig;
+};
 
-export { FujiContext, MainnetContext };
+export { DevnetContext, FujiContext, MainnetContext };

package/esm/Avalanche/providers/constants.js

@@ -1 +1 @@
-const e={xBlockchainID:"2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM",pBlockchainID:"11111111111111111111111111111111LpoYY",cBlockchainID:"2q9e4r6Mu3U68nU1fYjgbR6JvwrRx36CohpAX5UQxse55x1Q5",avaxAssetID:"FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z",baseTxFee:BigInt(1e6),createAssetTxFee:BigInt(1e7),createSubnetTxFee:BigInt(1e9),transformSubnetTxFee:BigInt(1e10),createBlockchainTxFee:BigInt(1e9),addPrimaryNetworkValidatorFee:BigInt(0),addPrimaryNetworkDelegatorFee:BigInt(0),addSubnetValidatorFee:BigInt(1e6),addSubnetDelegatorFee:BigInt(1e6),networkID:1,hrp:"avax"},t={xBlockchainID:"2JVSBoinj9C2J33VntvzYtVJNZdN2NKiwwKjcumHUWEb5DbBrm",pBlockchainID:"11111111111111111111111111111111LpoYY",cBlockchainID:"yH8D7ThNJkxmtkuv2jgBa4P1Rn3Qpr4pPr7QYNfcdoS6k6HWp",avaxAssetID:"U8iRqJoiJm8xZHAacmvYyZVwqQx6uDNtQeP3CQ6fcgQk3JqnK",baseTxFee:BigInt(1e6),createAssetTxFee:BigInt(1e7),createSubnetTxFee:BigInt(1e8),transformSubnetTxFee:BigInt(1e9),createBlockchainTxFee:BigInt(1e8),addPrimaryNetworkValidatorFee:BigInt(0),addPrimaryNetworkDelegatorFee:BigInt(0),addSubnetValidatorFee:BigInt(1e6),addSubnetDelegatorFee:BigInt(1e6),networkID:5,hrp:"fuji"};export{t as FujiContext,e as MainnetContext};
+import{platformFeeConfig as e}from"./platformFeeConfig.js";const t={xBlockchainID:"2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM",pBlockchainID:"11111111111111111111111111111111LpoYY",cBlockchainID:"2q9e4r6Mu3U68nU1fYjgbR6JvwrRx36CohpAX5UQxse55x1Q5",avaxAssetID:"FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z",baseTxFee:BigInt(1e6),createAssetTxFee:BigInt(1e7),createSubnetTxFee:BigInt(1e9),transformSubnetTxFee:BigInt(1e10),createBlockchainTxFee:BigInt(1e9),addPrimaryNetworkValidatorFee:BigInt(0),addPrimaryNetworkDelegatorFee:BigInt(0),addSubnetValidatorFee:BigInt(1e6),addSubnetDelegatorFee:BigInt(1e6),networkID:1,hrp:"avax",platformFeeConfig:e},a={xBlockchainID:"2JVSBoinj9C2J33VntvzYtVJNZdN2NKiwwKjcumHUWEb5DbBrm",pBlockchainID:"11111111111111111111111111111111LpoYY",cBlockchainID:"yH8D7ThNJkxmtkuv2jgBa4P1Rn3Qpr4pPr7QYNfcdoS6k6HWp",avaxAssetID:"U8iRqJoiJm8xZHAacmvYyZVwqQx6uDNtQeP3CQ6fcgQk3JqnK",baseTxFee:BigInt(1e6),createAssetTxFee:BigInt(1e7),createSubnetTxFee:BigInt(1e8),transformSubnetTxFee:BigInt(1e9),createBlockchainTxFee:BigInt(1e8),addPrimaryNetworkValidatorFee:BigInt(0),addPrimaryNetworkDelegatorFee:BigInt(0),addSubnetValidatorFee:BigInt(1e6),addSubnetDelegatorFee:BigInt(1e6),networkID:5,hrp:"fuji",platformFeeConfig:e},n={addPrimaryNetworkDelegatorFee:0n,addPrimaryNetworkValidatorFee:0n,addSubnetDelegatorFee:1000000n,addSubnetValidatorFee:1000000n,avaxAssetID:"22jjRVdyTJiAEtcZciAVR8bTFyVDUVoo1T3o5PiDspQSZ2maXR",baseTxFee:1000000n,cBlockchainID:"vV3cui1DsEPC3nLCGH9rorwo8s6BYxM2Hz4QFE5gEYjwTqAu",createAssetTxFee:1000000n,createBlockchainTxFee:100000000n,createSubnetTxFee:100000000n,hrp:"custom",networkID:76,pBlockchainID:"11111111111111111111111111111111LpoYY",transformSubnetTxFee:100000000n,xBlockchainID:"2piQ2AVHCjnduiWXsSY15DtbVuwHE2cwMHYnEXHsLL73BBkdbV",platformFeeConfig:e};export{n as DevnetContext,a as FujiContext,t as MainnetContext};

package/esm/Avalanche/providers/platformFeeConfig.js

@@ -0,0 +1 @@
+import{Common as e}from"@avalabs/avalanchejs";const t={weights:e.createDimensions({bandwidth:1,dbRead:1e3,dbWrite:1e3,compute:4}),maxCapacity:BigInt(1e6),maxPerSecond:BigInt(1e5),targetPerSecond:BigInt(5e4),minPrice:BigInt(1),excessConversionConstant:BigInt(2164043)};export{t as platformFeeConfig};

package/esm/Avalanche/utils/convertGlacierUtxo.d.ts

@@ -1,7 +1,7 @@
-import { Utxo as Utxo$1 } from '@avalabs/avalanchejs';
-import { Utxo, PChainUtxo } from '@avalabs/glacier-sdk';
+import { Utxo as Utxo$1, TransferOutput, pvmSerial } from '@avalabs/avalanchejs';
+import { Utxo, PChainUtxo, Network } from '@avalabs/glacier-sdk';
 
 type GlacierOutput = Utxo | PChainUtxo;
-declare const convertGlacierUtxo: (glacierUtxo: GlacierOutput, isTestnet: boolean) => Utxo$1;
+declare const convertGlacierUtxo: (glacierUtxo: GlacierOutput, network: Network) => Utxo$1<TransferOutput | pvmSerial.StakeableLockOut<TransferOutput>>;
 
 export { GlacierOutput, convertGlacierUtxo };

package/esm/Avalanche/utils/createAvalancheUnsignedTx.js

@@ -1 +1 @@
-import{UnsignedTx as r,utils as e}from"@avalabs/avalanchejs";import{isSubnetTx as t,handleSubnetAuth as a}from"./handleSubnetAuth.js";const{getTransferableInputsByTx:s,AddressMaps:n}=e,o=async({tx:e,fromAddressBytes:o,provider:i,credentials:d,utxos:p})=>{const u=s(e),f=n.fromTransferableInputs(u,p,BigInt(Math.floor((new Date).getTime()/1e3)),o);if(t(e))try{const t=await a({tx:e,provider:i,addressMaps:f});return new r(e,p,t,d)}catch(r){throw new Error(`Error while preparing subnet authorization data: ${r.message}`)}return new r(e,p,f,d)};export{o as createAvalancheUnsignedTx,o as default};
+import{UnsignedTx as e,pvmSerial as r,utils as a}from"@avalabs/avalanchejs";import{isSubnetTx as t,handleSubnetAuth as s}from"./handleSubnetAuth.js";const{getTransferableInputsByTx:n,AddressMaps:i}=a,o=async({tx:o,fromAddressBytes:d,provider:l,credentials:u,utxos:p})=>{const h=n(o),c=i.fromTransferableInputs(h,p,BigInt(Math.floor((new Date).getTime()/1e3)),d);if(t(o))try{const r=await s({tx:o,provider:l,addressMaps:c});return new e(o,p,r,u)}catch(e){throw new Error(`Error while preparing subnet authorization data: ${e.message}`)}else if(r.isDisableL1ValidatorTx(o))try{const{deactivationOwner:e}=await l.getApiP().getL1Validator(o.validationId.toString()),r=o.getDisableAuth().values(),t=e.addresses.reduce(((e,a,t)=>(r.includes(t)&&e.push([a,t]),e)),[]);c.push(new a.AddressMap(t))}catch(e){throw new Error(`Error while preparing subnet authorization data: ${e.message}`)}return new e(o,p,c,u)};export{o as createAvalancheUnsignedTx,o as default};

package/esm/Avalanche/utils/getChainAliasByChainId.js

@@ -1 +1 @@
-import"@avalabs/avalanchejs";import"@avalabs/core-utils-sdk";import"ethers";import{FujiContext as r,MainnetContext as o}from"../providers/constants.js";import"@avalabs/core-chains-sdk";const a=(a,n)=>{const{cBlockchainID:t,xBlockchainID:c,pBlockchainID:i}=n?r:o;if(t===a)return"C";if(c===a)return"X";if(i===a)return"P";throw new Error(`Unknown chainId "${a}"`)};export{a as getChainAliasByChainId};
+import{Network as r}from"@avalabs/glacier-sdk";import"@avalabs/avalanchejs";import"@avalabs/core-utils-sdk";import"ethers";import{DevnetContext as a,FujiContext as o,MainnetContext as i}from"../providers/constants.js";import"@avalabs/core-chains-sdk";const n=(n,s)=>{const t=s===r.FUJI,c=s===r.DEVNET,{cBlockchainID:e,xBlockchainID:l,pBlockchainID:p}=c?a:t?o:i;if(e===n)return"C";if(l===n)return"X";if(p===n)return"P";throw new Error(`Unknown chainId "${n}"`)};export{n as getChainAliasByChainId};

package/esm/Avalanche/utils/getPchainUnixNow.js

@@ -1 +1 @@
-import{JsonRpcProvider as e}from"../providers/JsonRpcProvider.js";async function t(t){const i=t?e.getDefaultFujiProvider():e.getDefaultMainnetProvider(),r=await i.getApiP().getTimestamp(),o=new Date(r.timestamp),a=Math.floor(o.getTime()/1e3);return BigInt(a)}export{t as getPchainUnixNow};
+import{AVALANCHE_XP_TEST_NETWORK as a,AVALANCHE_XP_NETWORK as t}from"@avalabs/core-chains-sdk";import{pvm as e}from"@avalabs/avalanchejs";async function r(r){const i=r?a.rpcUrl:t.rpcUrl,n=await new e.PVMApi(i).getTimestamp(),o=new Date(n.timestamp),m=Math.floor(o.getTime()/1e3);return BigInt(m)}export{r as getPchainUnixNow};

package/esm/Avalanche/utils/getUtxosByTxFromGlacier.d.ts

@@ -1,13 +1,16 @@
+import * as _avalabs_avalanchejs_dist_serializable_common_types from '@avalabs/avalanchejs/dist/serializable/common/types';
+import { Network } from '@avalabs/glacier-sdk';
 import { Utxo } from '@avalabs/avalanchejs';
 import { ChainIDAlias } from '../models.js';
 
 type Params = {
     transactionHex: string;
     chainAlias: ChainIDAlias;
-    isTestnet: boolean;
+    network: Network;
     url: string;
     token?: string;
+    headers?: Record<string, string>;
 };
-declare const getUtxosByTxFromGlacier: ({ transactionHex, chainAlias, isTestnet, url, token, }: Params) => Promise<Utxo[]>;
+declare const getUtxosByTxFromGlacier: ({ transactionHex, chainAlias, network, url, token, headers, }: Params) => Promise<Utxo<_avalabs_avalanchejs_dist_serializable_common_types.Serializable>[]>;
 
 export { getUtxosByTxFromGlacier };

package/esm/Avalanche/utils/getUtxosByTxFromGlacier.js

@@ -1 +1 @@
-import{Glacier as t,Network as r,BlockchainId as o}from"@avalabs/glacier-sdk";import{evmSerial as e,utils as n,avmSerial as a,pvmSerial as i,PVM as s,AVM as x,EVM as c}from"@avalabs/avalanchejs";import{getVmByChainAlias as u}from"./getVmByChainAlias.js";import{convertGlacierUtxo as I}from"./convertGlacierUtxo.js";const{getTransferableInputsByTx:p,hexToBuffer:f,unpackWithManager:l}=n,m=async({transactionHex:n,chainAlias:m,isTestnet:h,url:T,token:d})=>{const w=u(m),g=f(n),D=l(w,g);if(e.isExportTx(D))return[];const b=(t=>{if(e.isImportTx(t)||a.isImportTx(t)||i.isImportTx(t))return t.sourceChain.toString();const r=t.getVM();switch(r){case c:return o.C_CHAIN;case x:return o.X_CHAIN;case s:return o.P_CHAIN;default:throw new Error(`Unable to get chain for VM type "${r}"`)}})(D),A=p(D),E=new t({BASE:T,TOKEN:d}),H=h?r.FUJI:r.MAINNET,N=[...new Set(A.map((t=>t.utxoID.txID.toString())))],U=await Promise.all(N.map((t=>E.primaryNetworkTransactions.getTxByHash({blockchainId:b,network:H,txHash:t}))));return A.reduce(((t,r)=>{const o=U.find((t=>t.txHash===r.utxoID.txID.toString()));if(!o)throw new Error(`Unable to find parent tx "${r.utxoID.txID.toString()}"`);const e=o.emittedUtxos.find((t=>t.utxoId===r.utxoID.ID()));if(!e)throw new Error(`Unable to find UTXO "${r.utxoID.ID()}" at index "${r.utxoID.outputIdx.value()}"`);const n=I(e,h);return t.push(n),t}),[])};export{m as getUtxosByTxFromGlacier};
+import{Glacier as t,BlockchainId as r}from"@avalabs/glacier-sdk";import{evmSerial as o,utils as e,avmSerial as n,pvmSerial as a,PVM as i,AVM as s,EVM as x}from"@avalabs/avalanchejs";import{getVmByChainAlias as c}from"./getVmByChainAlias.js";import{convertGlacierUtxo as u}from"./convertGlacierUtxo.js";const{getTransferableInputsByTx:I,hexToBuffer:p,unpackWithManager:f}=e,h=async({transactionHex:e,chainAlias:h,network:l,url:m,token:d,headers:w})=>{const D=c(h),g=p(e),T=f(D,g);if(o.isExportTx(T))return[];const E=(t=>{if(o.isImportTx(t)||n.isImportTx(t)||a.isImportTx(t))return t.sourceChain.toString();const e=t.getVM();switch(e){case x:return r.C_CHAIN;case s:return r.X_CHAIN;case i:return r.P_CHAIN;default:throw new Error(`Unable to get chain for VM type "${e}"`)}})(T),H=I(T),b=new t({BASE:m,TOKEN:d,HEADERS:w}),k=[...new Set(H.map((t=>t.utxoID.txID.toString())))],A=await Promise.all(k.map((t=>b.primaryNetworkTransactions.getTxByHash({blockchainId:E,network:l,txHash:t}))));return H.reduce(((t,r)=>{const o=A.find((t=>t.txHash===r.utxoID.txID.toString()));if(!o)throw new Error(`Unable to find parent tx "${r.utxoID.txID.toString()}"`);const e=o.emittedUtxos.find((t=>t.utxoId===r.utxoID.ID()));if(!e)throw new Error(`Unable to find UTXO "${r.utxoID.ID()}" at index "${r.utxoID.outputIdx.value()}"`);const n=u(e,l);return t.push(n),t}),[])};export{h as getUtxosByTxFromGlacier};

package/esm/Avalanche/utils/handleSubnetAuth.js

@@ -1 +1 @@
-import{pvmSerial as e,utils as s}from"@avalabs/avalanchejs";const t=s=>e.isCreateChainTx(s)||e.isAddSubnetValidatorTx(s)||e.isRemoveSubnetValidatorTx(s)||e.isTransformSubnetTx(s)||e.isTransferSubnetOwnershipTx(s),a=async({tx:e,provider:t,addressMaps:a})=>{const n=e.getSubnetAuth().values(),r=(await t.getApiP().getTx({txID:e.getSubnetID().value()})).unsignedTx.getSubnetOwners().addrs.reduce(((e,s,t)=>(n.includes(t)&&e.push([s,t]),e)),[]);return a.push(new s.AddressMap(r)),a};export{a as handleSubnetAuth,t as isSubnetTx};
+import{pvmSerial as e,OutputOwners as t,utils as s}from"@avalabs/avalanchejs";const a=t=>e.isCreateChainTx(t)||e.isAddSubnetValidatorTx(t)||e.isRemoveSubnetValidatorTx(t)||e.isTransformSubnetTx(t)||e.isTransferSubnetOwnershipTx(t)||e.isConvertSubnetToL1Tx(t),r=async({tx:e,provider:a,addressMaps:r})=>{const n=e.getSubnetAuth().values(),i=await a.getApiP().getSubnet({subnetID:e.getSubnetID().value()}),u=t.fromNative(i.controlKeys.map((e=>s.parse(e)[2])),BigInt(i.locktime),Number(i.threshold)).addrs.reduce(((e,t,s)=>(n.includes(s)&&e.push([t,s]),e)),[]);return r.push(new s.AddressMap(u)),r};export{r as handleSubnetAuth,a as isSubnetTx};

package/esm/Avalanche/utils/parseAvalancheTx.d.ts

@@ -2,9 +2,15 @@ import { Common } from '@avalabs/avalanchejs';
 import { Tx } from '../models.js';
 import { JsonRpcProvider } from '../providers/JsonRpcProvider.js';
 
+type ParseOptions = {
+    /**
+     * Tolerance percentage range where the burned amount is considered valid.
+     */
+    feeTolerance?: number;
+};
 /**
  * Returns human readable data from a given a transaction buffer,
  */
-declare function parseAvalancheTx(unsignedTx: Common.UnsignedTx, provider: JsonRpcProvider, currentAddress: string): Promise<Tx>;
+declare function parseAvalancheTx(unsignedTx: Common.UnsignedTx, provider: JsonRpcProvider, currentAddress: string, { feeTolerance }?: ParseOptions): Promise<Tx>;
 
 export { parseAvalancheTx };

package/esm/Avalanche/utils/parseAvalancheTx.js

@@ -1 +1 @@
-import{evmSerial as t,utils as e}from"@avalabs/avalanchejs";import{TxType as n}from"../models.js";import a from"./parsers/index.js";const{getBurnedAmountByTx:r,getOutputAmounts:o,getInputAmounts:s,validateBurnedAmount:u}=e;async function i(e,i,x){try{const n=i.getContext(),d=e.getTx(),m=(t=>{for(const e of Object.values(a)){const n=e(t);if(null!==n)return n}throw new Error("no parser found for tx")})(d),A=r(d),g=o(d),p=s(d).get(n.avaxAssetID)??BigInt(0),v=A.get(n.avaxAssetID)??BigInt(0),c=g.get(n.avaxAssetID)??BigInt(0),{isValid:l,txFee:I}=u({unsignedTx:e,context:n,burnedAmount:v,...t.isImportExportTx(d)&&{evmBaseFee:await i.getApiC().getBaseFee()/BigInt(1e9),evmFeeTolerance:50}});return await m({feeData:{totalAvaxBurned:v,totalAvaxOutput:c,totalAvaxInput:p,isValidAvaxBurnedAmount:l,txFee:I},assetId:n.avaxAssetID,provider:i,currentAddress:x})}catch(t){return{type:n.Unknown}}}export{i as parseAvalancheTx};
+import{evmSerial as t,utils as e}from"@avalabs/avalanchejs";import{TxType as n}from"../models.js";import a from"./parsers/index.js";const{getBurnedAmountByTx:r,getOutputAmounts:o,getInputAmounts:s,validateBurnedAmount:u}=e;async function i(e,i,g,{feeTolerance:x=50}={}){try{const n=i.getContext(),p=e.getTx(),c=(t=>{for(const e of Object.values(a)){const n=e(t);if(null!==n)return n}throw new Error("no parser found for tx")})(p),d=r(p,n),A=o(p),I=s(p).get(n.avaxAssetID)??BigInt(0),l=d.get(n.avaxAssetID)??BigInt(0),m=A.get(n.avaxAssetID)??BigInt(0);let f,v=BigInt(0);t.isImportExportTx(p)?v=await i.getApiC().getBaseFee()/BigInt(1e9):"PVM"===p.vm&&(f=i.getUpgradesInfo(),v=await i.getApiP().getFeeState().then((t=>t.price)).catch((()=>BigInt(0))));const{isValid:B,txFee:w}=u({upgradesInfo:f,unsignedTx:e,context:n,burnedAmount:l,baseFee:v,feeTolerance:x});return await c({feeData:{totalAvaxBurned:l,totalAvaxOutput:m,totalAvaxInput:I,isValidAvaxBurnedAmount:B,txFee:w},assetId:n.avaxAssetID,provider:i,currentAddress:g})}catch(t){return{type:n.Unknown}}}export{i as parseAvalancheTx};

package/esm/Avalanche/utils/parsers/index.js

@@ -1 +1 @@
-import r from"./parseAddValidatorTx.js";import e from"./parseAddDelegatorTx.js";import s from"./parseCreateSubnetTx.js";import a from"./parseCreateChainTx.js";import o from"./parseAddSubnetValidorTx.js";import p from"./parseImportTx.js";import t from"./parseExportTx.js";import m from"./parseBaseTx.js";import i from"./parseAddPermissionlessValidatorTx.js";import T from"./parseAddPermissionlessDelegatorTx.js";import d from"./parseRemoveSubnetValidatorTx.js";import x from"./parseTransformSubnetTx.js";import n from"./parseTransferSubnetOwnershipTx.js";var f={parseAddValidatorTx:r,parseAddDelegatorTx:e,parseCreateSubnetTx:s,parseCreateChainTx:a,parseAddSubnetValidatorTx:o,parseRemoveSubnetValidatorTx:d,parseImportTx:p,parseExportTx:t,parseBaseTx:m,parseAddPermissionlessValidatorTx:i,parseAddPermissionlessDelegatorTx:T,parseTransformSubnetTx:x,parseTransferSubnetOwnershipTx:n};export{f as default};
+import r from"./parseAddValidatorTx.js";import e from"./parseAddDelegatorTx.js";import a from"./parseCreateSubnetTx.js";import s from"./parseCreateChainTx.js";import o from"./parseAddSubnetValidorTx.js";import t from"./parseImportTx.js";import p from"./parseExportTx.js";import i from"./parseBaseTx.js";import m from"./parseAddPermissionlessValidatorTx.js";import T from"./parseAddPermissionlessDelegatorTx.js";import x from"./parseRemoveSubnetValidatorTx.js";import d from"./parseTransformSubnetTx.js";import n from"./parseTransferSubnetOwnershipTx.js";import l from"./parseConvertSubnetToL1Tx.js";import f from"./parseRegisterL1ValidatorTx.js";import j from"./parseSetL1ValidatorWeightTx.js";import V from"./parseDisableL1ValidatorTx.js";import b from"./parseIncreaseL1ValidatorBalanceTx.js";var S={parseAddValidatorTx:r,parseAddDelegatorTx:e,parseCreateSubnetTx:a,parseCreateChainTx:s,parseAddSubnetValidatorTx:o,parseRemoveSubnetValidatorTx:x,parseImportTx:t,parseExportTx:p,parseBaseTx:i,parseAddPermissionlessValidatorTx:m,parseAddPermissionlessDelegatorTx:T,parseTransformSubnetTx:d,parseTransferSubnetOwnershipTx:n,parseConvertSubnetTx:l,parseRegisterL1ValidatorTx:f,parseIncreaseL1ValidatorBalanceTx:b,parseSetL1ValidatorWeightTx:j,parseDisableL1ValidatorTx:V};export{S as default};

package/esm/Avalanche/utils/parsers/parseAddPermissionlessDelegatorTx.js

@@ -1 +1 @@
-import{pvmSerial as e}from"@avalabs/avalanchejs";import{TxType as a}from"../../models.js";const t=t=>e.isAddPermissionlessDelegatorTx(t)?({feeData:e,assetId:s})=>({type:a.AddPermissionlessDelegator,chain:t.getVM(),stake:t.subnetValidator.validator.weight.value(),nodeID:t.subnetValidator.validator.nodeId.value(),start:t.subnetValidator.validator.startTime.value().toString(),end:t.subnetValidator.validator.endTime.value().toString(),subnetID:t.subnetValidator.subnetId.value(),stakeOuts:t.stake,delegatorRewardsOwner:t.getDelegatorRewardsOwner(),...e}):null;export{t as default};
+import{pvmSerial as e}from"@avalabs/avalanchejs";import{TxType as a}from"../../models.js";const t=t=>e.isAddPermissionlessDelegatorTx(t)?({feeData:e})=>({type:a.AddPermissionlessDelegator,chain:t.getVM(),stake:t.subnetValidator.validator.weight.value(),nodeID:t.subnetValidator.validator.nodeId.value(),start:t.subnetValidator.validator.startTime.value().toString(),end:t.subnetValidator.validator.endTime.value().toString(),subnetID:t.subnetValidator.subnetId.value(),stakeOuts:t.stake,delegatorRewardsOwner:t.getDelegatorRewardsOwner(),...e}):null;export{t as default};

package/esm/Avalanche/utils/parsers/parseAddPermissionlessValidatorTx.js

@@ -1 +1 @@
-import{pvmSerial as e,utils as a}from"@avalabs/avalanchejs";import{TxType as t}from"../../models.js";const r=r=>{if(!e.isAddPermissionlessValidatorTx(r))return null;let s,i;return e.isSigner(r.signer)&&(i=a.bufferToHex(r.signer.proof.publicKey),s=a.bufferToHex(r.signer.proof.signature)),({feeData:e,assetId:a})=>({type:t.AddPermissionlessValidator,chain:r.getVM(),stake:r.subnetValidator.validator.weight.value(),nodeID:r.subnetValidator.validator.nodeId.value(),start:r.subnetValidator.validator.startTime.value().toString(),end:r.subnetValidator.validator.endTime.value().toString(),subnetID:r.subnetValidator.subnetId.value(),delegationFee:r.shares.value(),stakeOuts:r.stake,rewardOwner:r.getValidatorRewardsOwner(),delegationRewardOwner:r.getDelegatorRewardsOwner(),signer:r.signer,publicKey:i,signature:s,...e})};export{r as default};
+import{pvmSerial as e,utils as a}from"@avalabs/avalanchejs";import{TxType as r}from"../../models.js";const t=t=>{if(!e.isAddPermissionlessValidatorTx(t))return null;let s,i;return e.isSigner(t.signer)&&(i=a.bufferToHex(t.signer.proof.publicKey),s=a.bufferToHex(t.signer.proof.signature)),({feeData:e})=>({type:r.AddPermissionlessValidator,chain:t.getVM(),stake:t.subnetValidator.validator.weight.value(),nodeID:t.subnetValidator.validator.nodeId.value(),start:t.subnetValidator.validator.startTime.value().toString(),end:t.subnetValidator.validator.endTime.value().toString(),subnetID:t.subnetValidator.subnetId.value(),delegationFee:t.shares.value(),stakeOuts:t.stake,rewardOwner:t.getValidatorRewardsOwner(),delegationRewardOwner:t.getDelegatorRewardsOwner(),signer:t.signer,publicKey:i,signature:s,...e})};export{t as default};

package/esm/Avalanche/utils/parsers/parseConvertSubnetToL1Tx.js

@@ -0,0 +1 @@
+import{pvmSerial as e,Address as a,NodeId as n}from"@avalabs/avalanchejs";import{TxType as t}from"../../models.js";const r=r=>e.isConvertSubnetToL1Tx(r)?({feeData:e,provider:o})=>{const s=o.getHrp(),i=e=>`P-${e.toString(s)}`;return{type:t.ConvertSubnetToL1,chain:r.getVM(),managerAddress:i(a.fromHex(r.address.toString("hex"))),validators:r.validators.map((e=>({nodeId:n.fromHex(e.nodeId.toString("hex")).toString(),stake:e.weight.value(),balance:e.balance.value(),remainingBalanceOwners:e.remainingBalanceOwner.addresses.map(i),deactivationOwners:e.deactivationOwner.addresses.map(i)}))),chainID:r.chainID.value(),subnetID:r.subnetID.value(),...e}}:null;export{r as default};

package/esm/Avalanche/utils/parsers/parseDisableL1ValidatorTx.js

@@ -0,0 +1 @@
+import{pvmSerial as a}from"@avalabs/avalanchejs";import{TxType as t}from"../../models.js";const i=i=>a.isDisableL1ValidatorTx(i)?({feeData:a})=>({type:t.DisableL1Validator,chain:i.getVM(),validationId:i.validationId.toString(),...a}):null;export{i as default};

package/esm/Avalanche/utils/parsers/parseIncreaseL1ValidatorBalanceTx.js

@@ -0,0 +1 @@
+import{pvmSerial as a}from"@avalabs/avalanchejs";import{TxType as e}from"../../models.js";const l=l=>a.isIncreaseL1ValidatorBalanceTx(l)?({feeData:a})=>({type:e.IncreaseL1ValidatorBalance,chain:l.getVM(),balance:l.balance.value(),validationId:l.validationId.toString(),...a}):null;export{l as default};

package/esm/Avalanche/utils/parsers/parseRegisterL1ValidatorTx.js

@@ -0,0 +1 @@
+import{pvmSerial as a}from"@avalabs/avalanchejs";import{TxType as e}from"../../models.js";const t=t=>a.isRegisterL1ValidatorTx(t)?({feeData:a})=>({type:e.RegisterL1Validator,chain:t.getVM(),balance:t.balance.value(),...a}):null;export{t as default};

package/esm/Avalanche/utils/parsers/parseSetL1ValidatorWeightTx.js

@@ -0,0 +1 @@
+import{pvmSerial as a}from"@avalabs/avalanchejs";import{TxType as t}from"../../models.js";const e=e=>a.isSetL1ValidatorWeightTx(e)?({feeData:a})=>({type:t.SetL1ValidatorWeight,chain:e.getVM(),...a}):null;export{e as default};

package/esm/Avalanche/utils/parsers/utils/chainIdToVm.js

@@ -1 +1 @@
-import"@avalabs/avalanchejs";import"@avalabs/core-utils-sdk";import"ethers";import{MainnetContext as a,FujiContext as c}from"../../../providers/constants.js";import"@avalabs/core-chains-sdk";const i=i=>{if([a.xBlockchainID,c.xBlockchainID].includes(i))return"AVM";if([a.pBlockchainID,c.pBlockchainID].includes(i))return"PVM";if([a.cBlockchainID,c.cBlockchainID].includes(i))return"EVM";throw new Error("Unknown chain id. Failed to get alias.")};export{i as default};
+import"@avalabs/avalanchejs";import"@avalabs/core-utils-sdk";import"ethers";import{MainnetContext as c,FujiContext as a,DevnetContext as i}from"../../../providers/constants.js";import"@avalabs/core-chains-sdk";const n=n=>{if([c.xBlockchainID,a.xBlockchainID,i.xBlockchainID].includes(n))return"AVM";if([c.pBlockchainID,a.pBlockchainID,i.pBlockchainID].includes(n))return"PVM";if([c.cBlockchainID,a.cBlockchainID,i.cBlockchainID].includes(n))return"EVM";throw new Error("Unknown chain id. Failed to get alias.")};export{n as default};

package/esm/Avalanche/utils/sortUTXOs.d.ts

@@ -1,3 +1,4 @@
+import * as _avalabs_avalanchejs_dist_serializable_common_types from '@avalabs/avalanchejs/dist/serializable/common/types';
 import { Utxo } from '@avalabs/avalanchejs';
 
 /**
@@ -6,9 +7,9 @@ import { Utxo } from '@avalabs/avalanchejs';
  * 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[];
+declare function sortUTXOsStaking(utxos: Utxo[]): Utxo<_avalabs_avalanchejs_dist_serializable_common_types.Serializable>[];
+declare function sortUTXOsByAmount(utxos: Utxo[], isDescending: boolean): Utxo<_avalabs_avalanchejs_dist_serializable_common_types.Serializable>[];
+declare const sortUTXOsByAmountDescending: (utxos: Utxo[]) => Utxo<_avalabs_avalanchejs_dist_serializable_common_types.Serializable>[];
+declare const sortUTXOsByAmountAscending: (utxos: Utxo[]) => Utxo<_avalabs_avalanchejs_dist_serializable_common_types.Serializable>[];
 
 export { sortUTXOsByAmount, sortUTXOsByAmountAscending, sortUTXOsByAmountDescending, sortUTXOsStaking };

package/esm/Avalanche/utils/txSizeLimits.d.ts

@@ -1,4 +1,4 @@
-import { Utxo } from '@avalabs/avalanchejs';
+import { Utxo, pvm } from '@avalabs/avalanchejs';
 import { WalletAbstract } from 'Avalanche/wallets';
 
 /**
@@ -25,8 +25,15 @@ declare const P_CHAIN_TX_SIZE_LIMIT = 65536;
  * @param utxos - list of UTXOs to be consumed by the transaction.
  * @param sizeSupportedTx - one of the supported transaction types
  * @param limit - optional - byte size limit, defaults to 64kb.
+ * @param feeState - current fee state on the chain
  * @returns the largest prefix of sorted `utxos` before hitting the size limit. If no such prefix exists, then an empty array.
  */
-declare function getMaximumUtxoSet(wallet: WalletAbstract, utxos: Utxo[], sizeSupportedTx: SizeSupportedTx, limit?: number): Utxo[];
+declare function getMaximumUtxoSet({ wallet, utxos, sizeSupportedTx, limit, feeState, }: {
+    wallet: WalletAbstract;
+    utxos: Utxo[];
+    sizeSupportedTx: SizeSupportedTx;
+    limit?: number;
+    feeState?: pvm.FeeState;
+}): Utxo[];
 
 export { P_CHAIN_TX_SIZE_LIMIT, SizeSupportedTx, getMaximumUtxoSet };

package/esm/Avalanche/utils/txSizeLimits.js

@@ -1 +1 @@
-import{utils as e}from"@avalabs/avalanchejs";import{getUtxoInfo as t}from"./getUtxoInfo.js";import{getUnixNow as o}from"./getUnixNow.js";import{binarySearch as r}from"../../utils/binarySearch.js";import{sortUTXOsByAmountDescending as s,sortUTXOsByAmountAscending as n,sortUTXOsStaking as i}from"./sortUTXOs.js";var d=(e=>(e.ExportP="ExportP",e.ImportP="ImportP",e.AddPermissionlessValidator="AddPermissionlessValidator",e.AddPermissionlessDelegator="AddPermissionlessDelegator",e.BaseP="BaseP",e.ConsolidateP="ConsolidateP",e))(d||{});const a="NodeID-8TArWpFgH3sazEH8qP4gUjtGtFMvjw1aR",c="11111111111111111111111111111111LpoYY",l=(e,o)=>e.reduce(((e,o)=>e+t(o).amount),BigInt(0))-o,u={BaseP:{sortFunction:s,unsignedTxBuilder:(t,o)=>{const r=t.getProvider().getContext();return t.baseTX(new e.UtxoSet(o),"P",t.getCurrentAddress("P"),{[r.avaxAssetID]:l(o,r.baseTxFee)})}},ConsolidateP:{sortFunction:n,unsignedTxBuilder:(t,o)=>{const r=t.getProvider().getContext();return t.consolidateP(new e.UtxoSet(o),l(o,r.baseTxFee))}},AddPermissionlessValidator:{sortFunction:i,unsignedTxBuilder:(t,r)=>t.addPermissionlessValidator(new e.UtxoSet(r),a,o(),o()+BigInt(1e3),l(r,t.getProvider().getContext().addPrimaryNetworkValidatorFee),c,5,void 0,void 0,void 0,Buffer.from(e.hexToBuffer("0x8f95423f7142d00a48e1014a3de8d28907d420dc33b3052a6dee03a3f2941a393c2351e354704ca66a3fc29870282e15")),Buffer.from(e.hexToBuffer("0x86a3ab4c45cfe31cae34c1d06f212434ac71b1be6cfe046c80c162e057614a94a5bc9f1ded1a7029deb0ba4ca7c9b71411e293438691be79c2dbf19d1ca7c3eadb9c756246fc5de5b7b89511c7d7302ae051d9e03d7991138299b5ed6a570a98")))},AddPermissionlessDelegator:{sortFunction:i,unsignedTxBuilder:(t,r)=>t.addPermissionlessDelegator(new e.UtxoSet(r),a,o(),o()+BigInt(1e3),l(r,t.getProvider().getContext().addPrimaryNetworkDelegatorFee),c)},ExportP:{sortFunction:s,unsignedTxBuilder:(t,o)=>t.exportP(l(o,t.getProvider().getContext().baseTxFee),new e.UtxoSet(o),"X")},ImportP:{sortFunction:s,unsignedTxBuilder:(t,o)=>t.importP(new e.UtxoSet(o),"X")}},x=65536;function P(e,s,n,i=65536){const{sortFunction:d,unsignedTxBuilder:a}=u[n],c=o(),l=d(s.filter((e=>{const{locktime:o,stakeableLocktime:r}=t(e);return o<c&&(r<c||("AddPermissionlessDelegator"===n||"AddPermissionlessValidator"===n))}))),x=r(l,(o=>{try{return function(e){const o=e.getInputUtxos().reduce(((e,o)=>e+(8+65*t(o).threshold)),0);return 6+e.toBytes().length+o}(a(e,o))}catch(e){return console.log("Unable to estimate size of utxos",{e:e,utxos:o.map(t)}),i+1}}),i);return-1===x?[]:l.slice(0,x+1)}export{x as P_CHAIN_TX_SIZE_LIMIT,d as SizeSupportedTx,P as getMaximumUtxoSet};
+import{utils as e}from"@avalabs/avalanchejs";import{getUtxoInfo as t}from"./getUtxoInfo.js";import{getUnixNow as o}from"./getUnixNow.js";import{binarySearch as s}from"../../utils/binarySearch.js";import{sortUTXOsByAmountDescending as r,sortUTXOsByAmountAscending as n,sortUTXOsStaking as d}from"./sortUTXOs.js";var a=(e=>(e.ExportP="ExportP",e.ImportP="ImportP",e.AddPermissionlessValidator="AddPermissionlessValidator",e.AddPermissionlessDelegator="AddPermissionlessDelegator",e.BaseP="BaseP",e.ConsolidateP="ConsolidateP",e))(a||{});const i="NodeID-8TArWpFgH3sazEH8qP4gUjtGtFMvjw1aR",u="11111111111111111111111111111111LpoYY",c=(e,o)=>e.reduce(((e,o)=>e+t(o).amount),BigInt(0))-o,l={BaseP:{sortFunction:r,unsignedTxBuilder:(t,o,s)=>{const r=t.getProvider().getContext();return t.baseTX({utxoSet:new e.UtxoSet(o),chain:"P",toAddress:t.getCurrentAddress("P"),amountsPerAsset:{[r.avaxAssetID]:c(o,r.baseTxFee)},feeState:s})}},ConsolidateP:{sortFunction:n,unsignedTxBuilder:(t,o,s)=>{const r=t.getProvider().getContext();return t.consolidateP({utxoSet:new e.UtxoSet(o),amount:c(o,r.baseTxFee),feeState:s})}},AddPermissionlessValidator:{sortFunction:d,unsignedTxBuilder:(t,s,r)=>t.addPermissionlessValidator({utxoSet:new e.UtxoSet(s),nodeId:i,start:o(),end:o()+BigInt(1e3),weight:c(s,t.getProvider().getContext().baseTxFee),subnetId:u,shares:5,feeState:r,fromAddresses:void 0,rewardAddresses:void 0,delegatorRewardAddresses:void 0,publicKey:Buffer.from(e.hexToBuffer("0x8f95423f7142d00a48e1014a3de8d28907d420dc33b3052a6dee03a3f2941a393c2351e354704ca66a3fc29870282e15")),signature:Buffer.from(e.hexToBuffer("0x86a3ab4c45cfe31cae34c1d06f212434ac71b1be6cfe046c80c162e057614a94a5bc9f1ded1a7029deb0ba4ca7c9b71411e293438691be79c2dbf19d1ca7c3eadb9c756246fc5de5b7b89511c7d7302ae051d9e03d7991138299b5ed6a570a98"))})},AddPermissionlessDelegator:{sortFunction:d,unsignedTxBuilder:(t,s,r)=>t.addPermissionlessDelegator({utxoSet:new e.UtxoSet(s),nodeId:i,start:o(),end:o()+BigInt(1e3),weight:c(s,t.getProvider().getContext().baseTxFee),subnetId:u,feeState:r})},ExportP:{sortFunction:r,unsignedTxBuilder:(t,o,s)=>t.exportP({amount:c(o,t.getProvider().getContext().baseTxFee),utxoSet:new e.UtxoSet(o),destination:"X",feeState:s})},ImportP:{sortFunction:r,unsignedTxBuilder:(t,o,s)=>t.importP({utxoSet:new e.UtxoSet(o),sourceChain:"X",feeState:s})}},x=65536;function f({wallet:e,utxos:r,sizeSupportedTx:n,limit:d=65536,feeState:a}){const{sortFunction:i,unsignedTxBuilder:u}=l[n],c=o(),x=i(r.filter((e=>{const{locktime:o,stakeableLocktime:s}=t(e);return o<c&&(s<c||("AddPermissionlessDelegator"===n||"AddPermissionlessValidator"===n))}))),f=s(x,(o=>{try{return function(e){const o=e.getInputUtxos().reduce(((e,o)=>e+(8+65*t(o).threshold)),0);return 6+e.toBytes().length+o}(u(e,o,a))}catch(e){return console.log("Unable to estimate size of utxos",{e:e,utxos:o.map(t)}),d+1}}),d);return-1===f?[]:x.slice(0,f+1)}export{x as P_CHAIN_TX_SIZE_LIMIT,a as SizeSupportedTx,f as getMaximumUtxoSet};

package/esm/Avalanche/wallets/AddressWallet.js

@@ -1 +1 @@
-import{WalletAbstract as s}from"./WalletAbstract.js";import"@avalabs/avalanchejs";import"../utils/populateCredential.js";import"@avalabs/core-utils-sdk";import{isAddress as e}from"ethers";import"../providers/constants.js";import"@avalabs/core-chains-sdk";import"create-hash";import"bip32";import"@avalabs/glacier-sdk";import"bip39";import{isBech32Address as r}from"../utils/isBech32Address.js";import"xss";import"bip32-path";class t extends s{constructor(s,t,a,d,i){if(super(i),this.addressC=s,this.addressCoreEth=t,this.xpAddresses=a,this.xpChangeAddress=d,a.length<1)throw new Error("Must have at least 1 xp address.");if(!e(s))throw new Error("Not a valid C-Chain (EVM) address");if(a.some((s=>!r(s,!1))))throw new Error("Given addresses must be valid avalanche bech32 addresses without the chain alias prefix");if(!r(t,!1))throw new Error("Given CoreEth address must be valid avalanche bech32 addresses without the chain alias prefix");this.setChangeAddress(d)}setChangeAddress(s){if(!r(s,!1))throw new Error("Given address must be valid avalanche bech32 addresses without the chain alias prefix");this.xpChangeAddress=s}getAddressEVM(){return this.addressC}getAddresses(s){return("C"===s?[this.addressCoreEth]:this.xpAddresses).map((e=>this.provider.formatAddress(e,s)))}getChangeAddress(s){const e="C"===s?this.addressCoreEth:this.xpChangeAddress;return this.provider.formatAddress(e,s)}getCurrentAddress(s){const e="C"===s?this.addressCoreEth:this.xpAddresses[0];return this.provider.formatAddress(e,s)}}export{t as AddressWallet};
+import{WalletAbstract as s}from"./WalletAbstract.js";import"@avalabs/avalanchejs";import"../utils/populateCredential.js";import"@avalabs/glacier-sdk";import"@avalabs/core-utils-sdk";import{isAddress as e}from"ethers";import"../providers/constants.js";import"@avalabs/core-chains-sdk";import"create-hash";import"bip32";import"bip39";import{isBech32Address as r}from"../utils/isBech32Address.js";import"xss";import"bip32-path";class t extends s{constructor(s,t,a,d,i){if(super(i),this.addressC=s,this.addressCoreEth=t,this.xpAddresses=a,this.xpChangeAddress=d,a.length<1)throw new Error("Must have at least 1 xp address.");if(!e(s))throw new Error("Not a valid C-Chain (EVM) address");if(a.some((s=>!r(s,!1))))throw new Error("Given addresses must be valid avalanche bech32 addresses without the chain alias prefix");if(!r(t,!1))throw new Error("Given CoreEth address must be valid avalanche bech32 addresses without the chain alias prefix");this.setChangeAddress(d)}setChangeAddress(s){if(!r(s,!1))throw new Error("Given address must be valid avalanche bech32 addresses without the chain alias prefix");this.xpChangeAddress=s}getAddressEVM(){return this.addressC}getAddresses(s){return("C"===s?[this.addressCoreEth]:this.xpAddresses).map((e=>this.provider.formatAddress(e,s)))}getChangeAddress(s){const e="C"===s?this.addressCoreEth:this.xpChangeAddress;return this.provider.formatAddress(e,s)}getCurrentAddress(s){const e="C"===s?this.addressCoreEth:this.xpAddresses[0];return this.provider.formatAddress(e,s)}}export{t as AddressWallet};

package/esm/Avalanche/wallets/SimpleSigner.js

@@ -1 +1 @@
-import{addTxSignatures as e,secp256k1 as t}from"@avalabs/avalanchejs";import{fromSeed as i}from"bip32";import{validateMnemonic as r,mnemonicToSeedSync as n}from"bip39";import"@ledgerhq/hw-app-eth";import"ethers";import{getAddressDerivationPath as o}from"../../utils/getAddressDerivationPath.js";import"hdkey";import"buffer";import{DerivationPath as s}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";import"../utils/populateCredential.js";import"../providers/constants.js";import"@avalabs/core-chains-sdk";import{digestMessage as a}from"../utils/digestMessage.js";import"@avalabs/glacier-sdk";import"xss";import"bip32-path";class c{accountNodeXP;signerNodeEVM;activeAccountIndex;constructor(e,t){if(!r(e))throw new Error("Invalid mnemonic phrase.");if(t<0||t%1!=0)throw new Error("Invalid account index.");const a=n(e),c=i(a);this.accountNodeXP=c.derivePath("m/44'/9000'/0'");const p=c.derivePath(o(t,s.BIP44,"EVM"));this.signerNodeEVM=p,this.activeAccountIndex=t}getAdditionalKeys(e,t){return[...new Set(e??[])].reduce(((e,i)=>{const r=this.accountNodeXP.derivePath(`${t?1:0}/${i}`);if(!r.privateKey)throw new Error("Unable to get private key.");return e.push(r.privateKey),e}),[])}getSigningKeys(e,t,i){if("EVM"===e){if(!this.signerNodeEVM.privateKey)throw new Error("Unable to derive EVM private key.");return[this.signerNodeEVM.privateKey]}const r=this.accountNodeXP.derivePath(`0/${this.activeAccountIndex}`);if(!r.privateKey)throw new Error("Unable to derive X/P private key.");const n=this.getAdditionalKeys(t,!1);if("AVM"===e){const e=this.getAdditionalKeys(i,!0);return[r.privateKey,...n,...e]}if("PVM"===e)return[r.privateKey,...n]}async signTx(t){const{tx:i,externalIndices:r,internalIndices:n}=t,o=i.getVM(),s=this.getSigningKeys(o,r,n);if(!s?.length)throw new Error("Unable to sign transaction: signing keys are missing.");return await e({unsignedTx:i,privateKeys:s}),t.tx}async signTxBuffer(e){throw new Error("Not implemented")}getActiveAccountNode(e){switch(e){case"X":case"P":return this.accountNodeXP.derivePath(`0/${this.activeAccountIndex}`);case"C":return this.signerNodeEVM}}async signMessage(e){const i=this.getActiveAccountNode(e.chain);if(!i.privateKey)throw Error("Unable to sign message, key not found.");const r=a(e.message),n=await t.signHash(r,i.privateKey);return Buffer.from(n)}}export{c as SimpleSigner};
+import{addTxSignatures as e,secp256k1 as t}from"@avalabs/avalanchejs";import{fromSeed as i}from"bip32";import{validateMnemonic as r,mnemonicToSeedSync as n}from"bip39";import"@ledgerhq/hw-app-eth";import"ethers";import{getAddressDerivationPath as o}from"../../utils/getAddressDerivationPath.js";import"hdkey";import"buffer";import{DerivationPath as s}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";import"../utils/populateCredential.js";import"@avalabs/glacier-sdk";import"../providers/constants.js";import"@avalabs/core-chains-sdk";import{digestMessage as a}from"../utils/digestMessage.js";import"xss";import"bip32-path";class c{accountNodeXP;signerNodeEVM;activeAccountIndex;constructor(e,t){if(!r(e))throw new Error("Invalid mnemonic phrase.");if(t<0||t%1!=0)throw new Error("Invalid account index.");const a=n(e),c=i(a);this.accountNodeXP=c.derivePath("m/44'/9000'/0'");const p=c.derivePath(o(t,s.BIP44,"EVM"));this.signerNodeEVM=p,this.activeAccountIndex=t}getAdditionalKeys(e,t){return[...new Set(e??[])].reduce(((e,i)=>{const r=this.accountNodeXP.derivePath(`${t?1:0}/${i}`);if(!r.privateKey)throw new Error("Unable to get private key.");return e.push(r.privateKey),e}),[])}getSigningKeys(e,t,i){if("EVM"===e){if(!this.signerNodeEVM.privateKey)throw new Error("Unable to derive EVM private key.");return[this.signerNodeEVM.privateKey]}const r=this.accountNodeXP.derivePath(`0/${this.activeAccountIndex}`);if(!r.privateKey)throw new Error("Unable to derive X/P private key.");const n=this.getAdditionalKeys(t,!1);if("AVM"===e){const e=this.getAdditionalKeys(i,!0);return[r.privateKey,...n,...e]}if("PVM"===e)return[r.privateKey,...n]}async signTx(t){const{tx:i,externalIndices:r,internalIndices:n}=t,o=i.getVM(),s=this.getSigningKeys(o,r,n);if(!s?.length)throw new Error("Unable to sign transaction: signing keys are missing.");return await e({unsignedTx:i,privateKeys:s}),t.tx}async signTxBuffer(e){throw new Error("Not implemented")}getActiveAccountNode(e){switch(e){case"X":case"P":return this.accountNodeXP.derivePath(`0/${this.activeAccountIndex}`);case"C":return this.signerNodeEVM}}async signMessage(e){const i=this.getActiveAccountNode(e.chain);if(!i.privateKey)throw Error("Unable to sign message, key not found.");const r=a(e.message),n=await t.signHash(r,i.privateKey);return Buffer.from(n)}}export{c as SimpleSigner};

package/esm/Avalanche/wallets/StaticSigner.js

@@ -1 +1 @@
-import{WalletVoid as i}from"./WalletVoid.js";import{addTxSignatures as r,secp256k1 as e,utils as t}from"@avalabs/avalanchejs";import{validateMnemonic as s,mnemonicToSeedSync as a}from"bip39";import{fromSeed as o}from"bip32";import{digestMessage as n}from"../utils/digestMessage.js";import"../utils/populateCredential.js";import"@avalabs/core-utils-sdk";import"ethers";import"../providers/constants.js";import"@avalabs/core-chains-sdk";import"@avalabs/glacier-sdk";import"xss";import{verifyDerivationPath as p}from"../utils/verifyDerivationPath.js";const{getPublicKey:m,sign:v,signHash:f}=e,{addChecksum:h}=t;class c extends i{privKeyXP;privKeyC;constructor(i,r,e){super(Buffer.from(m(i)),Buffer.from(m(r)),e),this.privKeyXP=i,this.privKeyC=r}static fromMnemonic(i,r,e,t){if(!s(i))throw new Error("Invalid mnemonic phrase.");if(!p(e)||!p(r))throw new Error("Not valid derivation path. Make sure it is a valid BIP44 path starting with m/");const n=a(i),m=o(n),v=m.derivePath(r),f=m.derivePath(e);if(!v.privateKey||!f.privateKey)throw new Error("Failed to generate private keys.");return new c(v.privateKey,f.privateKey,t)}async signMessage(i){const r=n(i.message),e=this.getSigningKey(i.chain);return Buffer.from(h(await f(r,e)))}getSigningKey(i){return"C"===i?this.privKeyC:this.privKeyXP}async signTx(i){return await r({unsignedTx:i.tx,privateKeys:[this.privKeyC,this.privKeyXP]}),i.tx}async signTxBuffer(i){const r=this.getSigningKey(i.chain);return[Buffer.from(await v(i.buffer,r))]}}export{c as StaticSigner};
+import{WalletVoid as i}from"./WalletVoid.js";import{addTxSignatures as r,secp256k1 as e,utils as t}from"@avalabs/avalanchejs";import{validateMnemonic as s,mnemonicToSeedSync as a}from"bip39";import{fromSeed as o}from"bip32";import{digestMessage as n}from"../utils/digestMessage.js";import"../utils/populateCredential.js";import"@avalabs/glacier-sdk";import"@avalabs/core-utils-sdk";import"ethers";import"../providers/constants.js";import"@avalabs/core-chains-sdk";import"xss";import{verifyDerivationPath as p}from"../utils/verifyDerivationPath.js";const{getPublicKey:m,sign:v,signHash:f}=e,{addChecksum:h}=t;class c extends i{privKeyXP;privKeyC;constructor(i,r,e){super(Buffer.from(m(i)),Buffer.from(m(r)),e),this.privKeyXP=i,this.privKeyC=r}static fromMnemonic(i,r,e,t){if(!s(i))throw new Error("Invalid mnemonic phrase.");if(!p(e)||!p(r))throw new Error("Not valid derivation path. Make sure it is a valid BIP44 path starting with m/");const n=a(i),m=o(n),v=m.derivePath(r),f=m.derivePath(e);if(!v.privateKey||!f.privateKey)throw new Error("Failed to generate private keys.");return new c(v.privateKey,f.privateKey,t)}async signMessage(i){const r=n(i.message),e=this.getSigningKey(i.chain);return Buffer.from(h(await f(r,e)))}getSigningKey(i){return"C"===i?this.privKeyC:this.privKeyXP}async signTx(i){return await r({unsignedTx:i.tx,privateKeys:[this.privKeyC,this.privKeyXP]}),i.tx}async signTxBuffer(i){const r=this.getSigningKey(i.chain);return[Buffer.from(await v(i.buffer,r))]}}export{c as StaticSigner};

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

@@ -0,0 +1,179 @@
+import { utils, pvm, Common } from '@avalabs/avalanchejs';
+
+type BaseTx = {
+    utxoSet: utils.UtxoSet;
+    chain: 'X' | 'P';
+    toAddress: string;
+    amountsPerAsset: Record<string, bigint>;
+    feeState?: pvm.FeeState;
+    options?: Common.SpendOptions;
+    fromAddresses?: string[];
+};
+type ImportP = {
+    utxoSet: utils.UtxoSet;
+    sourceChain: 'X' | 'C';
+    toAddress?: string;
+    threshold?: number;
+    feeState?: pvm.FeeState;
+    locktime?: bigint;
+};
+type ExportP = {
+    amount: bigint;
+    utxoSet: utils.UtxoSet;
+    destination: 'X' | 'C';
+    feeState?: pvm.FeeState;
+    toAddress?: string;
+};
+type ConsolidateP = {
+    utxoSet: utils.UtxoSet;
+    amount: bigint;
+    feeState?: pvm.FeeState;
+    toAddress?: string;
+    options?: Common.SpendOptions;
+};
+type CreateSubnet = {
+    utxoSet: utils.UtxoSet;
+    rewardAddresses: string[];
+    feeState?: pvm.FeeState;
+    fromAddresses?: string[];
+    options?: Common.SpendOptions;
+    threshold?: number;
+    locktime?: bigint;
+};
+type CreateChain = {
+    utxoSet: utils.UtxoSet;
+    subnetId: string;
+    chainName: string;
+    vmID: string;
+    fxIds: string[];
+    genesisData: Record<string, unknown>;
+    subnetAuth: number[];
+    feeState?: pvm.FeeState;
+    options?: Common.SpendOptions;
+    fromAddresses?: string[];
+};
+type ConvertSubnetToL1 = {
+    utxoSet: utils.UtxoSet;
+    address: string;
+    chainId: string;
+    subnetId: string;
+    subnetAuth: number[];
+    options?: Common.SpendOptions;
+    feeState: pvm.FeeState;
+    fromAddresses?: string[];
+    validators: {
+        nodeId: string;
+        weight: bigint;
+        balance: bigint;
+        pubKey: string;
+        signature: string;
+        remainingBalanceOwner: {
+            addresses: string[];
+            threshold?: number;
+        };
+        deactivationOwner: {
+            addresses: string[];
+            threshold?: number;
+        };
+    }[];
+};
+type RegisterL1Validator = {
+    utxoSet: utils.UtxoSet;
+    balance: bigint;
+    signature: string;
+    feeState: pvm.FeeState;
+    message: string;
+    options?: Common.SpendOptions;
+    fromAddresses?: string[];
+};
+type SetL1ValidatorWeight = {
+    utxoSet: utils.UtxoSet;
+    feeState: pvm.FeeState;
+    message: string;
+    options?: Common.SpendOptions;
+    fromAddresses?: string[];
+};
+type DisableL1Validator = {
+    utxoSet: utils.UtxoSet;
+    feeState: pvm.FeeState;
+    disableAuth: number[];
+    validationId: string;
+    options?: Common.SpendOptions;
+    fromAddresses?: string[];
+};
+type IncreaseL1ValidatorBalance = {
+    utxoSet: utils.UtxoSet;
+    feeState: pvm.FeeState;
+    balance: bigint;
+    validationId: string;
+    options?: Common.SpendOptions;
+    fromAddresses?: string[];
+};
+type AddSubnetValidator = {
+    utxoSet: utils.UtxoSet;
+    nodeId: string;
+    start: bigint;
+    end: bigint;
+    weight: bigint;
+    subnetId: string;
+    subnetAuth: number[];
+    feeState?: pvm.FeeState;
+    fromAddresses?: string[];
+    options?: Common.SpendOptions;
+};
+type 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;
+    stakingAssetId?: string;
+    locktime?: bigint;
+    threshold?: number;
+    feeState?: pvm.FeeState;
+};
+type AddPermissionlessDelegator = {
+    utxoSet: utils.UtxoSet;
+    nodeId: string;
+    start: bigint;
+    end: bigint;
+    weight: bigint;
+    subnetId: string;
+    fromAddresses?: string[];
+    rewardAddresses?: string[];
+    options?: Common.SpendOptions;
+    locktime?: bigint;
+    feeState?: pvm.FeeState;
+    stakingAssetId?: string;
+    threshold?: number;
+};
+type RemoveSubnetValidator = {
+    utxoSet: utils.UtxoSet;
+    nodeId: string;
+    subnetId: string;
+    subnetAuth: number[];
+    feeState?: pvm.FeeState;
+    fromAddresses?: string[];
+    options?: Common.SpendOptions;
+};
+type TransferSubnetOwnershipTx = {
+    utxoSet: utils.UtxoSet;
+    subnetId: string;
+    subnetAuth: number[];
+    subnetOwners: string[];
+    feeState?: pvm.FeeState;
+    fromAddresses?: string[];
+    options?: Common.SpendOptions;
+    threshold?: number;
+    locktime?: bigint;
+};
+
+export { AddPermissionlessDelegator, AddPermissionlessValidator, AddSubnetValidator, BaseTx, ConsolidateP, ConvertSubnetToL1, CreateChain, CreateSubnet, DisableL1Validator, ExportP, ImportP, IncreaseL1ValidatorBalance, RegisterL1Validator, RemoveSubnetValidator, SetL1ValidatorWeight, TransferSubnetOwnershipTx };

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

@@ -2,6 +2,7 @@ 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';
+import { ImportP, ExportP, ConsolidateP, BaseTx, ConvertSubnetToL1, RegisterL1Validator, SetL1ValidatorWeight, DisableL1Validator, IncreaseL1ValidatorBalance, CreateChain, CreateSubnet, AddSubnetValidator, AddPermissionlessValidator, AddPermissionlessDelegator, RemoveSubnetValidator, TransferSubnetOwnershipTx } from './TxBuilderTypes.js';
 
 /**
  * An  abstract class that that is shared by all wallet classes.
@@ -48,8 +49,12 @@ declare abstract class WalletAbstract {
      * @param source What is the source chain of the atomic UTXOs
      */
     getAtomicUTXOs(chain: ChainIDAlias, source: ChainIDAlias): Promise<utils.UtxoSet>;
+    /**
+     * Get the nonce of this wallet's C chain address
+     */
+    getNonce(): Promise<number>;
     exportX(amount: bigint, utxoSet: utils.UtxoSet, destination: 'P' | 'C', toAddress?: string): Common.UnsignedTx;
-    importP(utxos: utils.UtxoSet, sourceChain: 'X' | 'C', toAddress?: string): Common.UnsignedTx;
+    importP({ utxoSet, sourceChain, toAddress, threshold, feeState, locktime, }: ImportP): Common.UnsignedTx;
     importX(utxos: utils.UtxoSet, sourceChain: 'P' | 'C', toAddress?: string): Common.UnsignedTx;
     /**
      *
@@ -69,10 +74,6 @@ declare abstract class WalletAbstract {
      * @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
@@ -80,18 +81,23 @@ declare abstract class WalletAbstract {
      * @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?: {
+    exportP({ amount, utxoSet, destination, feeState, toAddress }: ExportP): 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?: {
+    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;
+    consolidateP({ utxoSet, amount, feeState, toAddress, options, }: ConsolidateP): Common.UnsignedTx;
+    baseTX({ utxoSet, chain, toAddress, amountsPerAsset, feeState, options, fromAddresses, }: BaseTx): Common.UnsignedTx;
+    convertSubnetToL1({ utxoSet, chainId, subnetId, subnetAuth, feeState, address, validators, options, fromAddresses, }: ConvertSubnetToL1): Common.UnsignedTx;
+    registerL1Validator({ utxoSet, balance, signature, message, feeState, fromAddresses, options, }: RegisterL1Validator): Common.UnsignedTx;
+    setL1ValidatorWeight({ utxoSet, feeState, message, options, fromAddresses, }: SetL1ValidatorWeight): Common.UnsignedTx;
+    disableL1Validator({ utxoSet, feeState, options, fromAddresses, disableAuth, validationId, }: DisableL1Validator): Common.UnsignedTx;
+    increaseL1ValidatorBalance({ utxoSet, feeState, options, fromAddresses, balance, validationId, }: IncreaseL1ValidatorBalance): Common.UnsignedTx;
+    createBlockchain({ utxoSet, subnetId, chainName, vmID, fxIds, genesisData, subnetAuth, feeState, options, fromAddresses, }: CreateChain): Common.UnsignedTx;
+    createSubnet({ utxoSet, rewardAddresses, feeState, fromAddresses, options, threshold, locktime, }: CreateSubnet): Common.UnsignedTx;
+    addSubnetValidator({ utxoSet, nodeId, start, end, weight, subnetId, subnetAuth, feeState, fromAddresses, options, }: AddSubnetValidator): Common.UnsignedTx;
     /**
      *
      * @param utxoSet The transaction will be constructed from these UTXOs.
@@ -108,7 +114,7 @@ declare abstract class WalletAbstract {
      * @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;
+    addPermissionlessValidator({ utxoSet, nodeId, start, end, weight, subnetId, shares, feeState, fromAddresses, rewardAddresses, delegatorRewardAddresses, publicKey, signature, options, threshold, locktime, stakingAssetId, }: AddPermissionlessValidator): Common.UnsignedTx;
     /**
      *
      * @param utxoSet The transaction will be constructed from these UTXOs.
@@ -121,10 +127,10 @@ declare abstract class WalletAbstract {
      * @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;
+    addPermissionlessDelegator({ utxoSet, nodeId, start, end, weight, subnetId, fromAddresses, rewardAddresses, options, locktime, feeState, threshold, stakingAssetId, }: AddPermissionlessDelegator): Common.UnsignedTx;
+    removeSubnetValidator({ utxoSet, nodeId, subnetId, subnetAuth, fromAddresses, feeState, options, }: RemoveSubnetValidator): Common.UnsignedTx;
+    transferSubnetOwnershipTx({ utxoSet, subnetId, subnetAuth, subnetOwners, feeState, fromAddresses, options, threshold, locktime, }: TransferSubnetOwnershipTx): 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: bigint, maxValidatorWeightFactor: number, uptimeRequirement: number, subnetAuth: number[], fromAddresses?: string[], options?: Common.SpendOptions): Common.UnsignedTx;
     protected constructor(provider: AbstractProvider);
 }