@moonbeam-network/xcm-sdk 2.7.10 → 3.0.1

package/build/index.mjs

@@ -1,2 +1,768 @@
-import{CallType as xt}from"@moonbeam-network/xcm-builder";import{AssetAmount as k}from"@moonbeam-network/xcm-types";import{convertDecimals as W,toBigInt as Dt,toDecimal as Et}from"@moonbeam-network/xcm-utils";import tt from"big.js";import{Contract as pt}from"ethers";import{createPublicClient as gt,getContract as yt,http as ht}from"viem";function B(n){return"provider"in n}function C(n){return!("abi"in n)}var A=[{constant:!0,inputs:[],name:"name",outputs:[{name:"",type:"string"}],payable:!1,stateMutability:"view",type:"function"},{constant:!1,inputs:[{name:"_spender",type:"address"},{name:"_value",type:"uint256"}],name:"approve",outputs:[{name:"",type:"bool"}],payable:!1,stateMutability:"nonpayable",type:"function"},{constant:!0,inputs:[],name:"totalSupply",outputs:[{name:"",type:"uint256"}],payable:!1,stateMutability:"view",type:"function"},{constant:!1,inputs:[{name:"_from",type:"address"},{name:"_to",type:"address"},{name:"_value",type:"uint256"}],name:"transferFrom",outputs:[{name:"",type:"bool"}],payable:!1,stateMutability:"nonpayable",type:"function"},{constant:!0,inputs:[],name:"decimals",outputs:[{name:"",type:"uint8"}],payable:!1,stateMutability:"view",type:"function"},{constant:!0,inputs:[{name:"_owner",type:"address"}],name:"balanceOf",outputs:[{name:"balance",type:"uint256"}],payable:!1,stateMutability:"view",type:"function"},{constant:!0,inputs:[],name:"symbol",outputs:[{name:"",type:"string"}],payable:!1,stateMutability:"view",type:"function"},{constant:!1,inputs:[{name:"_to",type:"address"},{name:"_value",type:"uint256"}],name:"transfer",outputs:[{name:"",type:"bool"}],payable:!1,stateMutability:"nonpayable",type:"function"},{constant:!0,inputs:[{name:"_owner",type:"address"},{name:"_spender",type:"address"}],name:"allowance",outputs:[{name:"",type:"uint256"}],payable:!1,stateMutability:"view",type:"function"},{payable:!0,stateMutability:"payable",type:"fallback"},{anonymous:!1,inputs:[{indexed:!0,name:"owner",type:"address"},{indexed:!0,name:"spender",type:"address"},{indexed:!1,name:"value",type:"uint256"}],name:"Approval",type:"event"},{anonymous:!1,inputs:[{indexed:!0,name:"from",type:"address"},{indexed:!0,name:"to",type:"address"},{indexed:!1,name:"value",type:"uint256"}],name:"Transfer",type:"event"}];var T=class{address;#t;#e;constructor(t,e){if(!t.address)throw new Error("Contract address is required");this.address=t.address,this.#t=t,this.#e=B(e)?new pt(this.address,A,e):yt({abi:A,address:this.address,client:{public:gt({chain:e.chain,transport:ht()}),wallet:e}})}async getBalance(){return C(this.#e)?(await this.#e.balanceOf(...this.#t.args)).toBigInt():this.#e.read.balanceOf(this.#t.args)}async getDecimals(){return C(this.#e)?await this.#e.decimals():this.#e.read.decimals()}};import{Contract as At}from"ethers";import{createPublicClient as J,getContract as bt,http as U}from"viem";var O=[{inputs:[{internalType:"address",name:"currencyAddress",type:"address"},{internalType:"uint256",name:"amount",type:"uint256"},{components:[{internalType:"uint8",name:"parents",type:"uint8"},{internalType:"bytes[]",name:"interior",type:"bytes[]"}],internalType:"struct Xtokens.Multilocation",name:"destination",type:"tuple"},{internalType:"uint64",name:"weight",type:"uint64"}],name:"transfer",outputs:[],stateMutability:"nonpayable",type:"function"},{inputs:[{components:[{internalType:"address",name:"currencyAddress",type:"address"},{internalType:"uint256",name:"amount",type:"uint256"}],internalType:"struct Xtokens.Currency[]",name:"currencies",type:"tuple[]"},{internalType:"uint32",name:"feeItem",type:"uint32"},{components:[{internalType:"uint8",name:"parents",type:"uint8"},{internalType:"bytes[]",name:"interior",type:"bytes[]"}],internalType:"struct Xtokens.Multilocation",name:"destination",type:"tuple"},{internalType:"uint64",name:"weight",type:"uint64"}],name:"transferMultiCurrencies",outputs:[],stateMutability:"nonpayable",type:"function"}];var x=class{defaultMoonChainAddress="0x0000000000000000000000000000000000000804";address;#t;#e;#a;constructor(t,e,a){this.#t=t,this.#a=e,this.address=a??this.defaultMoonChainAddress,this.#e=B(e)?new At(this.address,O,e):bt({abi:O,address:this.address,client:{public:J({chain:e.chain,transport:U()}),wallet:e}})}async transfer(){return C(this.#e)?this.#e[this.#t.func](...this.#t.args):this.#e.write[this.#t.func](this.#t.args)}async getEthersContractEstimatedGas(t){return t[this.#t.func].estimateGas(...this.#t.args)}async getViemContractEstimatedGas(t){return t?t.estimateGas[this.#t.func](this.#t.args):0n}async getFee(t){if(t===0n)return 0n;try{let e=C(this.#e)?await this.getEthersContractEstimatedGas(this.#e):await this.getViemContractEstimatedGas(this.#e),a=await this.getGasPrice();return e*a}catch(e){throw console.error(e),new Error("Can't get a fee. Make sure that you have enough balance!")}}async getGasPrice(){if(B(this.#a)){if(!this.#a.provider)return 0n;let{gasPrice:e,maxPriorityFeePerGas:a}=await this.#a.provider.getFeeData();return(e||0n)+(a||0n)}return J({chain:this.#a.chain,transport:U()}).getGasPrice()}};import{createPublicClient as Pt,http as St}from"viem";var F=class{address;#t;#e;constructor(t,e){if(!t.address)throw new Error("Contract address is required");this.address=t.address,this.#t=t,this.#e=Pt({chain:e,transport:St()})}async getBalance(){return await this.#e.readContract({abi:A,address:this.#t.address,args:this.#t.args,functionName:"balanceOf"})}async getDecimals(){return await this.#e.readContract({abi:A,address:this.#t.address,functionName:"decimals"})}};function wt(n,t,e){var a;if(n.module==="Erc20")return new T(n,t);if(n.module==="Xtokens"){if(e&&"contracts"in e){let s=(a=e==null?void 0:e.contracts)==null?void 0:a.Xtokens;return new x(n,t,s)}return new x(n,t)}throw new Error(`Contract ${n.module} not found`)}function b(n,t){if(n.module==="Erc20")return new F(n,t.getViemChain());throw new Error(`Public Contract ${n.module} not found`)}function M(n,t,e){return t?wt(n,t,e):b(n,e)}import{CallType as Y}from"@moonbeam-network/xcm-builder";import{convertDecimals as vt,toBigInt as Bt}from"@moonbeam-network/xcm-utils";async function y({address:n,chain:t,balanceBuilder:e,asset:a,decimals:s,polkadot:o}){let i=e.build({address:n,asset:o.chain.getBalanceAssetId(a)});if(i.type===Y.Substrate){let r=await o.query(i);return t.usesChainDecimals?vt(r,o.decimals,s):r}return await b(i,t).getBalance()}async function h({address:n,asset:t,config:e,polkadot:a,chain:s,assetBuiltConfig:o}){let i=o||e.balance.build({address:n,asset:a.chain.getBalanceAssetId(t||e.asset)});return i.type===Y.Substrate?a.getAssetDecimals(t||e.asset):b(i,s).getDecimals()}async function G(n,t){if(n.min)return t.query(n.min.build({asset:t.chain.getMinAssetId(n.asset)}));let e=t.chain.getAssetMin(n.asset);if(e){let a=await t.getAssetDecimals(n.asset);return Bt(e,a)}return 0n}function Z({amount:n,source:t,destination:e}){if(!e.chain.checkSovereignAccountBalances||!e.sovereignAccountBalances)return;let{feeAssetBalance:a,transferAssetBalance:s}=e.sovereignAccountBalances;if(n>s)throw new Error(`${t.chain.name} Sovereign account in ${e.chain.name} does not have enough balance for this transaction`);if(a&&t.destinationFee.amount>a)throw new Error(`${t.chain.name} Sovereign account in ${e.chain.name} does not have enough balance to pay for fees for this transaction`)}async function at({transferConfig:n,destinationAddress:t,destinationFee:e,polkadot:a,sourceAddress:s,evmSigner:o}){var _,V,z,K,j,L,H;let{asset:i,destination:m,source:{chain:c,config:r}}=n,u=k.fromAsset(i,{amount:0n,decimals:await h({address:t,chain:c,config:r,polkadot:a})}),f=a.chain.getBalanceAssetId(((_=r==null?void 0:r.fee)==null?void 0:_.asset)||r.asset),p=(V=r.fee)==null?void 0:V.balance.build({address:t,asset:f}),d=(z=r.fee)!=null&&z.asset?await h({address:t,asset:r.fee.asset,assetBuiltConfig:p,chain:c,config:r,polkadot:a}):void 0,l=(K=r.fee)!=null&&K.asset?k.fromAsset(r.fee.asset,{amount:0n,decimals:d||0}):u,w=(j=r.destinationFee)!=null&&j.asset?k.fromAsset(r.destinationFee.asset,{amount:0n,decimals:await h({address:t,asset:r.destinationFee.asset,chain:c,config:r,polkadot:a})}):u,g=await y({address:s,asset:r.asset,balanceBuilder:r.balance,chain:c,decimals:u.decimals,polkadot:a}),D=await et({address:s,balance:g,chain:c,decimals:l.decimals,feeConfig:r.fee,polkadot:a}),E=r.asset.isEqual(r.destinationFee.asset)?g:await et({address:s,balance:g,chain:c,decimals:w.decimals,feeConfig:r.destinationFee,polkadot:a}),I=await G(r,a),v=(L=r.extrinsic)==null?void 0:L.build({address:t,amount:g,asset:c.getAssetId(i),destination:m.chain,fee:e.amount,feeAsset:c.getAssetId(e),palletInstance:c.getAssetPalletInstance(i),source:c}),mt=(H=r.contract)==null?void 0:H.build({address:t,amount:g,asset:c.getAssetId(i),destination:m.chain,fee:e.amount,feeAsset:c.getAssetId(e)}),q=w.copyWith({amount:E}),ut=await It({balance:g,chain:c,contract:mt,decimals:l.decimals,destinationFeeBalanceAmount:q,destinationFeeConfig:r.destinationFee,evmSigner:o,extrinsic:v,feeConfig:r.fee,polkadot:a,sourceAddress:s}),$=u.copyWith({amount:g}),{existentialDeposit:N}=a,Q=l.copyWith({amount:ut}),lt=l.copyWith({amount:D}),X=u.copyWith({amount:I}),ft=Gt({balanceAmount:$,existentialDeposit:N,feeAmount:Q,minAmount:X});return{balance:$,chain:c,destinationFee:e,destinationFeeBalance:q,existentialDeposit:N,fee:Q,feeBalance:lt,max:ft,min:X}}async function et({address:n,balance:t,chain:e,decimals:a,feeConfig:s,polkadot:o}){if(!s)return t;let i=s.balance.build({address:n,asset:o.chain.getBalanceAssetId(s.asset)});if(i.type===xt.Evm){let c=b(i,e),r=await c.getDecimals(),u=await c.getBalance();return e.usesChainDecimals?W(u,o.decimals,r):u}let m=await o.query(i);return e.usesChainDecimals?W(m,o.decimals,a):m}async function It({balance:n,chain:t,contract:e,decimals:a,destinationFeeConfig:s,destinationFeeBalanceAmount:o,evmSigner:i,extrinsic:m,feeConfig:c,polkadot:r,sourceAddress:u}){if(e){if(!i)throw new Error("EVM Signer must be provided");if(s&&o&&typeof s.amount=="number"){let f=Number(Et(o.amount,o.decimals));if(f&&s.amount>f)throw new Error(`Can't get a fee, make sure you have ${s==null?void 0:s.amount} ${s==null?void 0:s.asset.originSymbol} in your source balance, needed for destination fees`)}return Tt({balance:n,chain:t,config:e,decimals:a,evmSigner:i})}if(m){let f=await Ft(n,m,r,u),p=Mt(a,c),d=f+p;return t.usesChainDecimals?W(d,r.decimals,a):d}throw new Error("Either contract or extrinsic must be provided")}async function Tt({balance:n,config:t,decimals:e,evmSigner:a,chain:s}){let i=await M(t,a,s).getFee(n);return W(i,18,e)}async function Ft(n,t,e,a){try{return await e.getFee(a,t)}catch(s){if(n)throw s;return 0n}}function Mt(n,t){return t!=null&&t.xcmDeliveryFeeAmount?Dt(t.xcmDeliveryFeeAmount,n):0n}function Gt({balanceAmount:n,existentialDeposit:t,feeAmount:e,minAmount:a}){let s=n.toBig().minus(a.toBig()).minus(n.isSame(t)?t.toBig():tt(0)).minus(n.isSame(e)?e.toBig():tt(0));return n.copyWith({amount:s.lt(0)?0n:BigInt(s.toFixed())})}async function nt({address:n,chain:t,assets:e,polkadot:a}){let s=e.reduce((i,m)=>i.some(c=>c.asset.isEqual(m.asset))?i:[m,...i],[]);return await Promise.all(s.map(async i=>{let m=await h({address:n,asset:i.asset,chain:t,config:i,polkadot:a}),c=await y({address:n,asset:i.asset,balanceBuilder:i.balance,chain:t,decimals:m,polkadot:a});return k.fromAsset(i.asset,{amount:c,decimals:m})}))}import{ConfigBuilder as ot,ConfigService as ct}from"@moonbeam-network/xcm-config";import{convertDecimals as Nt,toBigInt as it}from"@moonbeam-network/xcm-utils";import S from"big.js";import"@polkadot/api-augment";import{AssetAmount as kt}from"@moonbeam-network/xcm-types";import{getPolkadotApi as Wt}from"@moonbeam-network/xcm-utils";var P=class n{api;chain;configService;constructor(t,e,a){this.api=t,this.chain=e,this.configService=a}static async create(t,e){return new n(await Wt(t.ws),t,e)}static async createMulti(t,e){return Promise.all(t.map(a=>n.create(a,e)))}get decimals(){return this.api.registry.chainDecimals.at(0)||12}get asset(){let t=this.api.registry.chainTokens.at(0),e=t==null?void 0:t.toString().toLowerCase();if(!e)throw new Error("No native symbol key found");let a=this.configService.getAsset(e);if(!a)throw new Error(`No asset found for key "${e}" and symbol "${t}"`);return a}get existentialDeposit(){var s,o;let t=(s=this.api.consts.balances)==null?void 0:s.existentialDeposit,e=(o=this.api.consts.eqBalances)==null?void 0:o.existentialDeposit,a=(t==null?void 0:t.toBigInt())||(e==null?void 0:e.toBigInt())||0n;return kt.fromAsset(this.asset,{amount:a,decimals:this.decimals})}async getAssetMeta(t){var i,m,c,r,u,f;let e=((i=this.api.query.assets)==null?void 0:i.metadata)||((m=this.api.query.assetRegistry)==null?void 0:m.assets)||((c=this.api.query.assetRegistry)==null?void 0:c.metadata)||((r=this.api.query.assetRegistry)==null?void 0:r.currencyMetadatas)||((u=this.api.query.assetRegistry)==null?void 0:u.assetMetadatas)||((f=this.api.query.assetRegistry)==null?void 0:f.assetMetadataMap);if(!e)return;let a=await e(t),s="unwrapOrDefault"in a?a.unwrapOrDefault():a;return{decimals:("unwrapOrDefault"in s.decimals?s.decimals.unwrapOrDefault():s.decimals).toNumber(),symbol:s.symbol.toString()}}async getAssetDecimalsFromQuery(t){var s;let e=(s=this.api.query.assetsRegistry)==null?void 0:s.assetDecimals;return e?(await e(t)).unwrapOrDefault().toNumber():void 0}async getAssetDecimals(t){var s;let e=this.chain.getMetadataAssetId(t),a=this.chain.getAssetDecimals(t)||await this.getAssetDecimalsFromQuery(e)||((s=await this.getAssetMeta(e))==null?void 0:s.decimals)||this.decimals;if(!a)throw new Error(`No decimals found for asset ${t.originSymbol}`);return a}async query(t){let e=await this.api.query[t.module][t.func](...t.args);return t.transform(e)}async getFee(t,e){let a=this.api.tx[e.module][e.func],s=e.getArgs(a);return(await a(...s).paymentInfo(t,{nonce:-1})).partialFee.toBigInt()}async transfer(t,e,a){let s=this.api.tx[e.module][e.func],o=e.getArgs(s);return(await s(...o).signAndSend(this.#t(a)?t:a,{nonce:-1,signer:this.#t(a)?a:void 0,withSignedTransaction:!0})).toString()}#t(t){return"signPayload"in t}};import{AssetAmount as st}from"@moonbeam-network/xcm-types";import{getSovereignAccountAddresses as Rt,toBigInt as Ot}from"@moonbeam-network/xcm-utils";async function rt({transferConfig:n,destinationAddress:t,polkadot:e}){let{asset:a,destination:{chain:s,config:o}}=n,i=st.fromAsset(a,{amount:0n,decimals:await h({address:t,chain:s,config:o,polkadot:e})}),m=await y({address:t,asset:o.asset,balanceBuilder:o.balance,chain:s,decimals:i.decimals,polkadot:e}),c=await G(o,e),r=i.copyWith({amount:m}),{existentialDeposit:u}=e,f=await qt({address:t,config:n,polkadot:e}),p=i.copyWith({amount:c});return{balance:r,chain:s,existentialDeposit:u,fee:f,min:p,sovereignAccountBalances:s.checkSovereignAccountBalances?await $t({decimals:i.decimals,polkadot:e,transferConfig:n}):void 0}}async function qt({address:n,config:t,polkadot:e}){let{amount:a,asset:s}=t.source.config.destinationFee,o=await e.getAssetDecimals(s),i=st.fromAsset(s,{amount:0n,decimals:o});if(Number.isFinite(a))return i.copyWith({amount:Ot(a,o)});let m=a.build({address:n,api:e.api,chain:e.chain,feeAsset:e.chain.getRegisteredAssetIdOrAddress(s),transferAsset:e.chain.getRegisteredAssetIdOrAddress(t.asset)});return i.copyWith({amount:await m.call()})}async function $t({transferConfig:n,decimals:t,polkadot:e}){var f;let{destination:{chain:a,config:s},source:{config:o}}=n,i=Rt(n.source.chain.parachainId),m=(f=o.destinationFee)==null?void 0:f.destinationBalance,c=a.isRelay?i.relay:i.generic,r=await y({address:c,asset:s.asset,balanceBuilder:s.balance,chain:a,decimals:t,polkadot:e});return{feeAssetBalance:m?await y({address:c,asset:o.destinationFee.asset,balanceBuilder:m,chain:a,decimals:t,polkadot:e}):void 0,transferAssetBalance:r}}async function R({configService:n,destinationAddress:t,evmSigner:e,polkadotSigner:a,sourceAddress:s,transferConfig:o}){let[i,m]=await P.createMulti([o.destination.chain,o.source.chain],n),c=await rt({destinationAddress:t,polkadot:i,transferConfig:o}),r=await Xt(m,c.fee),u=await at({destinationAddress:t,destinationFee:r,evmSigner:e,polkadot:m,sourceAddress:s,transferConfig:o});return{destination:c,getEstimate(f){let d=S(it(f,u.balance.decimals).toString()).minus(u.balance.isSame(r)?r.toBig():S(0));return u.balance.copyWith({amount:d.lt(0)?0n:BigInt(d.toFixed())})},isSwapPossible:!0,max:u.max,min:Qt(c),source:u,async swap(){return R({configService:n,destinationAddress:s,evmSigner:e,polkadotSigner:a,sourceAddress:t,transferConfig:{...o,destination:o.source,source:o.destination}})},async transfer(f){var E,I;let p=it(f,u.balance.decimals);Z({amount:p,destination:c,source:u});let{asset:d,source:{chain:l,config:w}}=o,g=(E=w.contract)==null?void 0:E.build({address:t,amount:p,asset:l.getAssetId(d),destination:c.chain,fee:r.amount,feeAsset:l.getAssetId(r)}),D=(I=w.extrinsic)==null?void 0:I.build({address:t,amount:p,asset:l.getAssetId(d),destination:c.chain,fee:r.amount,feeAsset:l.getAssetId(r),palletInstance:l.getAssetPalletInstance(d),source:l});if(g){if(!e)throw new Error("EVM Signer must be provided");return M(g,e,l).transfer().then(v=>typeof v=="object"?v.hash:v)}if(D){if(!a)throw new Error("Polkadot signer must be provided");return m.transfer(s,D,a)}throw new Error("Either contract or extrinsic must be provided")}}}function Qt({balance:n,existentialDeposit:t,fee:e,min:a}){let s=S(0).plus(n.isSame(e)?e.toBig():S(0)).plus(n.isSame(t)&&n.toBig().lt(t.toBig())?t.toBig():S(0)).plus(n.toBig().lt(a.toBig())?a.toBig():S(0));return n.copyWith({amount:BigInt(s.toFixed())})}async function Xt(n,t){let e=await n.getAssetDecimals(t);return t.decimals===e?t:t.copyWith({amount:Nt(t.amount,t.decimals,e),decimals:e})}function va(n){let t=(n==null?void 0:n.configService)??new ct;return{assets(e){let{assets:a,asset:s}=ot(t).assets(e);return{assets:a,asset(o){let{sourceChains:i,source:m}=s(o);return{sourceChains:i,source(c){let{destinationChains:r,destination:u}=m(c);return{destinationChains:r,destination(f){return{async accounts(p,d,l){return R({...n,configService:t,destinationAddress:d,evmSigner:(l==null?void 0:l.evmSigner)??(l==null?void 0:l.ethersSigner),sourceAddress:p,transferConfig:u(f).build(),polkadotSigner:l==null?void 0:l.polkadotSigner})}}}}}}}}},async getTransferData({destinationAddress:e,destinationKeyOrChain:a,ethersSigner:s,evmSigner:o,keyOrAsset:i,polkadotSigner:m,sourceAddress:c,sourceKeyOrChain:r}){return R({configService:t,destinationAddress:e,evmSigner:o??s,polkadotSigner:m,sourceAddress:c,transferConfig:ot(t).assets().asset(i).source(r).destination(a).build()})}}}async function Ba(n,t){let e=new ct,s=e.getChainConfig(n).getAssetsConfigs(),o=await P.create(n,e);return await nt({chain:n,assets:s,address:t,polkadot:o})}export{va as Sdk,nt as getAssetsBalances,y as getBalance,Tt as getContractFee,h as getDecimals,Ft as getExtrinsicFee,It as getFee,et as getFeeBalance,Gt as getMax,G as getMin,Ba as getParachainBalances,at as getSourceData,Z as validateSovereignAccountBalances};
+// src/services/polkadot/PolkadotService.ts
+import "@polkadot/api-augment";
+import { AssetAmount } from "@moonbeam-network/xcm-types";
+import { getPolkadotApi } from "@moonbeam-network/xcm-utils";
+var PolkadotService = class _PolkadotService {
+  api;
+  chain;
+  constructor(api, chain) {
+    this.api = api;
+    this.chain = chain;
+  }
+  static async create(chain) {
+    return new _PolkadotService(await getPolkadotApi(chain.ws), chain);
+  }
+  static async createMulti(chains) {
+    return Promise.all(
+      chains.map((chain) => _PolkadotService.create(chain))
+    );
+  }
+  get decimals() {
+    return this.api.registry.chainDecimals.at(0) || 12;
+  }
+  get existentialDeposit() {
+    const existentialDeposit = this.api.consts.balances?.existentialDeposit;
+    const eqExistentialDeposit = this.api.consts.eqBalances?.existentialDeposit;
+    const amount = existentialDeposit?.toBigInt() || eqExistentialDeposit?.toBigInt() || 0n;
+    return AssetAmount.fromChainAsset(this.chain.nativeAsset, { amount });
+  }
+  async query(config) {
+    const response = await this.api.query[config.module][config.func](
+      ...config.args
+    );
+    return config.transform(response);
+  }
+  getExtrinsic(config) {
+    const fn = this.api.tx[config.module][config.func];
+    const args = config.getArgs(fn);
+    return fn(...args);
+  }
+  getExtrinsicCallHash(config) {
+    return this.getExtrinsic(config).method.toHex();
+  }
+  async getPaymentInfo(account, config) {
+    const extrinsic = this.getExtrinsic(config);
+    return extrinsic.paymentInfo(account, { nonce: -1 });
+  }
+  async getFee(account, config) {
+    const info = await this.getPaymentInfo(account, config);
+    return info.partialFee.toBigInt();
+  }
+  async transfer(account, config, signer, statusCallback) {
+    const extrinsic = this.getExtrinsic(config);
+    const isSigner = this.#isSigner(signer);
+    const signOptions = {
+      nonce: -1,
+      signer: isSigner ? signer : void 0,
+      withSignedTransaction: true
+    };
+    const hash = await new Promise((resolve, reject) => {
+      extrinsic.signAndSend(isSigner ? account : signer, signOptions, (result) => {
+        if (result.isError || result.dispatchError) {
+          reject(
+            new Error(
+              result.dispatchError?.toString() || "Transaction failed"
+            )
+          );
+        }
+        if (result.txHash) {
+          resolve(result.txHash.toString());
+        }
+        statusCallback?.(result);
+      }).catch(reject);
+    });
+    return hash;
+  }
+  #isSigner(signer) {
+    return "signPayload" in signer;
+  }
+};
+
+// src/getTransferData/getTransferData.utils.ts
+import {
+  ContractConfig,
+  EvmQueryConfig,
+  SubstrateQueryConfig
+} from "@moonbeam-network/xcm-builder";
+import {
+  AssetAmount as AssetAmount2,
+  EvmChain,
+  EvmParachain,
+  Parachain
+} from "@moonbeam-network/xcm-types";
+import { convertDecimals, toBigInt } from "@moonbeam-network/xcm-utils";
+import Big from "big.js";
+
+// src/services/evm/EvmService.ts
+import {
+  http,
+  createPublicClient
+} from "viem";
+var EvmService = class _EvmService {
+  chain;
+  client;
+  static create(chain) {
+    return new _EvmService(chain);
+  }
+  constructor(chain) {
+    this.chain = chain;
+    this.client = createPublicClient({
+      chain: chain.getViemChain(),
+      transport: http()
+    });
+  }
+  async query(query) {
+    return this.client[query.func](...query.args);
+  }
+  async getFee(address, contract) {
+    const gas = await this.client.estimateContractGas({
+      abi: contract.abi,
+      account: address,
+      address: contract.address,
+      args: contract.args,
+      functionName: contract.func
+    });
+    const gasPrice = await this.client.getGasPrice();
+    return gas * gasPrice;
+  }
+  async getBalance(address, contract) {
+    const balance = await this.client.readContract({
+      abi: contract.abi,
+      address: contract.address,
+      args: [address],
+      functionName: "balanceOf"
+    });
+    if (typeof balance !== "bigint") {
+      throw new Error(
+        `Could not get balance on ${this.chain.name} for ${address} from contract ${contract.address}`
+      );
+    }
+    return balance;
+  }
+  async transfer(signer, contract) {
+    const { request } = await this.client.simulateContract({
+      abi: contract.abi,
+      account: signer.account,
+      address: contract.address,
+      args: contract.args,
+      functionName: contract.func
+    });
+    const hash = await signer.writeContract(request);
+    return hash;
+  }
+};
+
+// src/getTransferData/getTransferData.utils.ts
+async function getBalance({
+  address,
+  asset,
+  builder,
+  chain
+}) {
+  const config = builder.build({
+    address,
+    asset
+  });
+  const amount = AssetAmount2.fromChainAsset(asset, { amount: 0n });
+  if (SubstrateQueryConfig.is(config) && EvmParachain.isAnyParachain(chain)) {
+    const polkadot = await PolkadotService.create(chain);
+    const balance = await polkadot.query(config);
+    const converted = chain.usesChainDecimals ? convertDecimals(balance, polkadot.decimals, asset.decimals) : balance;
+    return amount.copyWith({ amount: converted });
+  }
+  if (EvmChain.is(chain) || EvmParachain.is(chain)) {
+    const evm = EvmService.create(chain);
+    if (ContractConfig.is(config)) {
+      const balance = await evm.getBalance(address, config);
+      return amount.copyWith({ amount: balance });
+    }
+    if (EvmQueryConfig.is(config)) {
+      const balance = await evm.query(config);
+      return amount.copyWith({ amount: balance });
+    }
+  }
+  throw new Error(
+    `Can't get balance for ${address} on chain ${chain.name} and asset ${asset.symbol}`
+  );
+}
+async function getAssetMin({
+  asset,
+  builder,
+  chain
+}) {
+  const zero = AssetAmount2.fromChainAsset(chain.getChainAsset(asset), {
+    amount: 0n
+  });
+  if (builder && EvmParachain.isAnyParachain(chain)) {
+    const polkadot = await PolkadotService.create(chain);
+    const min = await polkadot.query(
+      builder.build({ asset: zero.getMinAssetId(), address: zero.address })
+    );
+    return zero.copyWith({ amount: min });
+  }
+  if (zero.min) {
+    return zero.copyWith({ amount: zero.min });
+  }
+  return zero;
+}
+function getMin({
+  balance,
+  existentialDeposit,
+  fee,
+  min
+}) {
+  const result = Big(0).plus(balance.isSame(fee) ? fee.toBig() : Big(0)).plus(
+    existentialDeposit && balance.isSame(existentialDeposit) && balance.toBig().lt(existentialDeposit.toBig()) ? existentialDeposit.toBig() : Big(0)
+  ).plus(balance.toBig().lt(min.toBig()) ? min.toBig() : Big(0));
+  return balance.copyWith({
+    amount: BigInt(result.toFixed())
+  });
+}
+function getMax({
+  balance,
+  existentialDeposit,
+  fee,
+  min
+}) {
+  const result = balance.toBig().minus(min.toBig()).minus(
+    existentialDeposit && balance.isSame(existentialDeposit) ? existentialDeposit.toBig() : Big(0)
+  ).minus(balance.isSame(fee) ? fee.toBig() : Big(0));
+  return balance.copyWith({
+    amount: result.lt(0) ? 0n : BigInt(result.toFixed())
+  });
+}
+async function getDestinationFee({
+  address,
+  asset,
+  destination,
+  fee,
+  feeAsset
+}) {
+  const zero = AssetAmount2.fromChainAsset(destination.getChainAsset(feeAsset), {
+    amount: 0n
+  });
+  if (Number.isFinite(fee)) {
+    return zero.copyWith({
+      amount: fee
+    });
+  }
+  if (EvmParachain.isAnyParachain(destination)) {
+    const polkadot = await PolkadotService.create(destination);
+    const cfg = fee.build({
+      address,
+      api: polkadot.api,
+      asset: destination.getChainAsset(asset),
+      destination,
+      feeAsset: destination.getChainAsset(feeAsset)
+    });
+    return zero.copyWith({
+      amount: await cfg.call()
+    });
+  }
+  return zero;
+}
+function convertToChainDecimals({
+  asset,
+  target
+}) {
+  return AssetAmount2.fromChainAsset(target, {
+    amount: asset.convertDecimals(target.decimals).amount
+  });
+}
+async function getExistentialDeposit(chain) {
+  if (EvmParachain.isAnyParachain(chain)) {
+    const polkadot = await PolkadotService.create(chain);
+    return polkadot.existentialDeposit;
+  }
+  return void 0;
+}
+async function getDestinationFeeBalance({
+  balance,
+  feeBalance,
+  route,
+  sourceAddress
+}) {
+  if (route.destination.fee.asset.isEqual(balance)) {
+    return balance;
+  }
+  if (route.destination.fee.asset.isEqual(feeBalance)) {
+    return feeBalance;
+  }
+  if (!route.source.destinationFee?.balance) {
+    throw new Error(
+      "BalanceBuilder must be defined for source.destinationFee.balance for AssetRoute"
+    );
+  }
+  return getBalance({
+    address: sourceAddress,
+    asset: route.getDestinationFeeAssetOnSource(),
+    builder: route.source.destinationFee?.balance,
+    chain: route.source.chain
+  });
+}
+async function getExtrinsicFee({
+  address,
+  balance,
+  chain,
+  extrinsic,
+  feeBalance,
+  feeConfig
+}) {
+  try {
+    const polkadot = await PolkadotService.create(chain);
+    const fee = await polkadot.getFee(address, extrinsic);
+    const extra = feeConfig?.extra ? toBigInt(feeConfig.extra, feeBalance.decimals) : 0n;
+    const totalFee = fee + extra;
+    const converted = chain.usesChainDecimals ? convertDecimals(totalFee, polkadot.decimals, feeBalance.decimals) : totalFee;
+    return feeBalance.copyWith({ amount: converted });
+  } catch (error) {
+    if (balance.amount) {
+      throw error;
+    }
+    return feeBalance.copyWith({ amount: 0n });
+  }
+}
+async function getContractFee({
+  address,
+  balance,
+  chain,
+  contract,
+  destinationFee,
+  feeBalance,
+  feeConfig
+}) {
+  try {
+    if (balance.amount === 0n) {
+      return feeBalance.copyWith({ amount: 0n });
+    }
+    const evm = EvmService.create(chain);
+    const fee = await evm.getFee(address, contract);
+    const extra = feeConfig?.extra ? toBigInt(feeConfig.extra, feeBalance.decimals) : 0n;
+    return feeBalance.copyWith({ amount: fee + extra });
+  } catch (error) {
+    throw new Error(
+      `Can't get a fee, make sure you have ${destinationFee.toDecimal()} ${destinationFee.getSymbol()} in your source balance, needed for destination fees`,
+      { cause: error }
+    );
+  }
+}
+function validateSovereignAccountBalances({
+  amount,
+  sourceData,
+  destinationData
+}) {
+  if (!Parachain.is(destinationData.chain) || !destinationData.chain.checkSovereignAccountBalances || !destinationData.sovereignAccountBalances) {
+    return;
+  }
+  const { feeAssetBalance, transferAssetBalance } = destinationData.sovereignAccountBalances;
+  if (amount > transferAssetBalance) {
+    throw new Error(
+      `${sourceData.chain.name} Sovereign account in ${destinationData.chain.name} does not have enough balance for this transaction`
+    );
+  }
+  if (feeAssetBalance && sourceData.destinationFee.amount > feeAssetBalance) {
+    throw new Error(
+      `${sourceData.chain.name} Sovereign account in ${destinationData.chain.name} does not have enough balance to pay for fees for this transaction`
+    );
+  }
+}
+
+// src/getTransferData/getSourceData.ts
+async function getSourceData({
+  route,
+  destinationAddress,
+  destinationFee,
+  sourceAddress
+}) {
+  const source = route.source.chain;
+  const destination = route.destination.chain;
+  const [sourcePolkadot, destinationPolkadot] = await PolkadotService.createMulti([source, destination]);
+  const asset = source.getChainAsset(route.source.asset);
+  const feeAsset = route.source.fee ? source.getChainAsset(route.source.fee.asset) : asset;
+  const balance = await getBalance({
+    address: sourceAddress,
+    asset,
+    builder: route.source.balance,
+    chain: source
+  });
+  const feeBalance = route.source.fee ? await getBalance({
+    address: sourceAddress,
+    asset: feeAsset,
+    builder: route.source.fee.balance,
+    chain: source
+  }) : balance;
+  const destinationFeeBalance = await getDestinationFeeBalance({
+    balance,
+    feeBalance,
+    route,
+    sourceAddress
+  });
+  const existentialDeposit = await getExistentialDeposit(source);
+  const min = await getAssetMin({
+    asset,
+    builder: route.source.min,
+    chain: source
+  });
+  const extrinsic = route.extrinsic?.build({
+    asset: balance,
+    destination: route.destination.chain,
+    destinationAddress,
+    destinationApi: destinationPolkadot.api,
+    fee: destinationFee,
+    source,
+    sourceAddress,
+    sourceApi: sourcePolkadot.api
+  });
+  const contract = route.contract?.build({
+    asset: balance,
+    destination: route.destination.chain,
+    destinationAddress,
+    destinationApi: destinationPolkadot.api,
+    fee: destinationFee,
+    source,
+    sourceAddress,
+    sourceApi: sourcePolkadot.api
+  });
+  const fee = await getFee({
+    balance,
+    chain: source,
+    contract,
+    destinationFee,
+    extrinsic,
+    feeBalance,
+    feeConfig: route.source.fee,
+    sourceAddress
+  });
+  const max = getMax({
+    balance,
+    existentialDeposit,
+    fee,
+    min
+  });
+  return {
+    balance,
+    chain: source,
+    destinationFee,
+    destinationFeeBalance,
+    existentialDeposit,
+    fee,
+    feeBalance,
+    max,
+    min
+  };
+}
+async function getFee({
+  balance,
+  feeBalance,
+  chain,
+  contract,
+  destinationFee,
+  extrinsic,
+  feeConfig,
+  sourceAddress
+}) {
+  if (!contract && !extrinsic) {
+    throw new Error("Either contract or extrinsic must be provided");
+  }
+  if (contract) {
+    return getContractFee({
+      address: sourceAddress,
+      balance,
+      chain,
+      contract,
+      destinationFee,
+      feeBalance,
+      feeConfig
+    });
+  }
+  return getExtrinsicFee({
+    address: sourceAddress,
+    balance,
+    chain,
+    extrinsic,
+    feeBalance,
+    feeConfig
+  });
+}
+async function getAssetsBalances({
+  address,
+  chain,
+  routes
+}) {
+  const uniqueRoutes = routes.reduce((acc, route) => {
+    if (!acc.some((a) => a.source.asset.isEqual(route.source.asset))) {
+      return [route, ...acc];
+    }
+    return acc;
+  }, []);
+  const balances = await Promise.all(
+    uniqueRoutes.map(
+      async (route) => getBalance({
+        address,
+        asset: chain.getChainAsset(route.source.asset),
+        builder: route.source.balance,
+        chain
+      })
+    )
+  );
+  return balances;
+}
+
+// src/getTransferData/getDestinationData.ts
+import { Parachain as Parachain2 } from "@moonbeam-network/xcm-types";
+import { getSovereignAccountAddresses } from "@moonbeam-network/xcm-utils";
+async function getDestinationData({
+  route,
+  destinationAddress
+}) {
+  const destination = route.destination.chain;
+  const asset = destination.getChainAsset(route.destination.asset);
+  const balance = await getBalance({
+    address: destinationAddress,
+    asset,
+    builder: route.destination.balance,
+    chain: destination
+  });
+  const min = await getAssetMin({
+    asset,
+    builder: route.destination.min,
+    chain: destination
+  });
+  const fee = await getDestinationFee({
+    address: destinationAddress,
+    feeAsset: route.destination.fee.asset,
+    destination,
+    fee: route.destination.fee.amount,
+    asset: route.source.asset
+  });
+  const existentialDeposit = await getExistentialDeposit(destination);
+  return {
+    chain: destination,
+    balance,
+    existentialDeposit,
+    fee,
+    min,
+    sovereignAccountBalances: await getSovereignAccountBalances({
+      source: route.source,
+      destination: route.destination
+    })
+  };
+}
+async function getSovereignAccountBalances({
+  destination,
+  source
+}) {
+  if (!Parachain2.is(source.chain) || !Parachain2.is(destination.chain) || !destination.chain.checkSovereignAccountBalances) {
+    return void 0;
+  }
+  const sovereignAccountAddresses = getSovereignAccountAddresses(
+    source.chain.parachainId
+  );
+  const destinationFeeAssetBalance = destination.fee.balance;
+  const sovereignAccountAddress = destination.chain.isRelay ? sovereignAccountAddresses.relay : sovereignAccountAddresses.generic;
+  const sovereignAccountBalance = await getBalance({
+    address: sovereignAccountAddress,
+    asset: destination.chain.getChainAsset(destination.asset),
+    builder: destination.balance,
+    chain: destination.chain
+  });
+  const sovereignAccountFeeAssetBalance = destinationFeeAssetBalance ? await getBalance({
+    address: sovereignAccountAddress,
+    asset: destination.chain.getChainAsset(destination.fee.asset),
+    builder: destinationFeeAssetBalance,
+    chain: destination.chain
+  }) : void 0;
+  return {
+    feeAssetBalance: sovereignAccountFeeAssetBalance?.amount,
+    transferAssetBalance: sovereignAccountBalance.amount
+  };
+}
+
+// src/sdk.ts
+import { ConfigService, xcmRoutesMap } from "@moonbeam-network/xcm-config";
+import {
+  EvmParachain as EvmParachain2
+} from "@moonbeam-network/xcm-types";
+
+// src/getTransferData/getTransferData.ts
+import {
+  AssetAmount as AssetAmount3
+} from "@moonbeam-network/xcm-types";
+import { toBigInt as toBigInt2 } from "@moonbeam-network/xcm-utils";
+import Big2 from "big.js";
+async function getTransferData({
+  route,
+  sourceAddress,
+  destinationAddress
+}) {
+  const destinationData = await getDestinationData({
+    route,
+    destinationAddress
+  });
+  const destinationFee = convertToChainDecimals({
+    asset: destinationData.fee,
+    target: route.getDestinationFeeAssetOnSource()
+  });
+  const sourceData = await getSourceData({
+    route,
+    destinationAddress,
+    destinationFee,
+    sourceAddress
+  });
+  return {
+    destination: destinationData,
+    getEstimate(amount) {
+      const bigAmount = Big2(
+        toBigInt2(amount, sourceData.balance.decimals).toString()
+      );
+      const result = bigAmount.minus(
+        sourceData.balance.isSame(destinationFee) ? destinationFee.toBig() : Big2(0)
+      );
+      return sourceData.balance.copyWith({
+        amount: result.lt(0) ? 0n : BigInt(result.toFixed())
+      });
+    },
+    max: sourceData.max,
+    min: getMin(destinationData),
+    source: sourceData,
+    async transfer(amount, { evmSigner, polkadotSigner }) {
+      const source = route.source.chain;
+      const destination = route.destination.chain;
+      const bigintAmount = toBigInt2(amount, sourceData.balance.decimals);
+      validateSovereignAccountBalances({
+        amount: bigintAmount,
+        destinationData,
+        sourceData
+      });
+      const asset = AssetAmount3.fromChainAsset(
+        route.source.chain.getChainAsset(route.source.asset),
+        { amount: bigintAmount }
+      );
+      const [sourcePolkadot, destinationPolkadot] = await PolkadotService.createMulti([source, destination]);
+      const contract = route.contract?.build({
+        asset,
+        destination,
+        destinationAddress,
+        destinationApi: destinationPolkadot.api,
+        fee: destinationFee,
+        source,
+        sourceAddress,
+        sourceApi: sourcePolkadot.api
+      });
+      const extrinsic = route.extrinsic?.build({
+        asset,
+        destination,
+        destinationAddress,
+        destinationApi: destinationPolkadot.api,
+        fee: destinationFee,
+        source,
+        sourceAddress,
+        sourceApi: sourcePolkadot.api
+      });
+      if (contract) {
+        if (!evmSigner) {
+          throw new Error("EVM Signer must be provided");
+        }
+        const evm = EvmService.create(source);
+        return evm.transfer(evmSigner, contract);
+      }
+      if (extrinsic) {
+        if (!polkadotSigner) {
+          throw new Error("Polkadot signer must be provided");
+        }
+        return sourcePolkadot.transfer(
+          sourceAddress,
+          extrinsic,
+          polkadotSigner
+        );
+      }
+      throw new Error("Either contract or extrinsic must be provided");
+    }
+  };
+}
+
+// src/sdk.ts
+var DEFAULT_SERVICE = new ConfigService({ routes: xcmRoutesMap });
+function Sdk({ configService, ecosystem } = {}) {
+  const service = configService ?? DEFAULT_SERVICE;
+  const assets = service.getEcosystemAssets(ecosystem);
+  return {
+    assets,
+    setAsset(asset) {
+      const sources = service.getSourceChains({ asset, ecosystem });
+      return {
+        sources,
+        setSource(source) {
+          const destinations = service.getDestinationChains({
+            asset,
+            source
+          });
+          return {
+            destinations,
+            setDestination(destination) {
+              const route = service.getAssetRoute({
+                asset,
+                source,
+                destination
+              });
+              return {
+                setAddresses({
+                  sourceAddress,
+                  destinationAddress
+                }) {
+                  const sourceChain = service.getChain(source);
+                  if (!EvmParachain2.isAnyParachain(sourceChain)) {
+                    throw new Error(
+                      "Source chain should be a Parachain or EvmParachain"
+                    );
+                  }
+                  if (!EvmParachain2.isAnyParachain(route.destination.chain)) {
+                    throw new Error(
+                      "Destination chain should be a Parachain or EvmParachain"
+                    );
+                  }
+                  return getTransferData({
+                    route,
+                    sourceAddress,
+                    destinationAddress
+                  });
+                }
+              };
+            }
+          };
+        }
+      };
+    }
+  };
+}
+async function getParachainBalances(chain, address, service = DEFAULT_SERVICE) {
+  const routes = service.getChainRoutes(chain).getRoutes();
+  const balances = await getAssetsBalances({
+    chain,
+    routes,
+    address
+  });
+  return balances;
+}
+export {
+  EvmService,
+  PolkadotService,
+  Sdk,
+  convertToChainDecimals,
+  getAssetMin,
+  getAssetsBalances,
+  getBalance,
+  getContractFee,
+  getDestinationData,
+  getDestinationFee,
+  getDestinationFeeBalance,
+  getExistentialDeposit,
+  getExtrinsicFee,
+  getFee,
+  getMax,
+  getMin,
+  getParachainBalances,
+  getSourceData,
+  validateSovereignAccountBalances
+};
 //# sourceMappingURL=index.mjs.map