@moonbeam-network/xcm-sdk 1.0.0-dev.21 → 1.0.0-dev.210

package/build/index.mjs

@@ -1,2 +1,774 @@
-import{AssetAmount as G}from"@moonbeam-network/xcm-types";import{convertDecimals as ut}from"@moonbeam-network/xcm-utils";import V from"big.js";import{Contract as nt}from"ethers";import{createPublicClient as at,getContract as rt,http as st}from"viem";function w(a){return"provider"in a}function b(a){return"signer"in a}var k=[{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 I=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=w(e)?new nt(this.address,k,e):rt({abi:k,address:this.address,publicClient:at({chain:e.chain,transport:st()}),walletClient:e})}async getBalance(){return b(this.#e)?(await this.#e.balanceOf(...this.#t.args)).toBigInt():this.#e.read.balanceOf(this.#t.args)}async getDecimals(){return b(this.#e)?await this.#e.decimals():this.#e.read.decimals()}};import{Contract as ot}from"ethers";import{createPublicClient as z,getContract as ct,http as K}from"viem";var F=[{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 T=class{address="0x0000000000000000000000000000000000000804";#t;#e;#n;constructor(t,e){this.#t=t,this.#n=e,this.#e=w(e)?new ot(this.address,F,e):ct({abi:F,address:this.address,publicClient:z({chain:e.chain,transport:K()}),walletClient:e})}async transfer(){return b(this.#e)?this.#e[this.#t.func](...this.#t.args):this.#e.write[this.#t.func](this.#t.args)}async getEthersContractEstimatedGas(t){return(await t.estimateGas[this.#t.func](...this.#t.args)).toBigInt()}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=b(this.#e)?await this.getEthersContractEstimatedGas(this.#e):await this.getViemContractEstimatedGas(this.#e),n=await this.getGasPrice();return e*n}catch(e){throw console.error(e),new Error("Can't get a fee. Make sure that you have enough balance!")}}async getGasPrice(){if(w(this.#n)){let{gasPrice:e,maxPriorityFeePerGas:n}=await this.#n.getFeeData();return((e==null?void 0:e.toBigInt())||0n)+((n==null?void 0:n.toBigInt())||0n)}return z({chain:this.#n.chain,transport:K()}).getGasPrice()}};function g(a,t){if(a.module==="Erc20")return new I(a,t);if(a.module==="Xtokens")return new T(a,t);throw new Error(`Contract ${a.module} not found`)}import{CallType as N}from"@moonbeam-network/xcm-builder";import{toBigInt as mt}from"@moonbeam-network/xcm-utils";async function B({address:a,config:t,evmSigner:e,polkadot:n}){let r=t.balance.build({address:a,asset:n.chain.getBalanceAssetId(t.asset)});if(r.type===N.Substrate)return n.query(r);if(!e)throw new Error("Evm signer must be provided");return g(r,e).getBalance()}async function y({address:a,asset:t,config:e,evmSigner:n,polkadot:r}){let s=e.balance.build({address:a,asset:r.chain.getBalanceAssetId(t||e.asset)});if(s.type===N.Substrate)return r.getAssetDecimals(t||e.asset);if(!n)throw new Error("Evm signer must be provided");return g(s,n).getDecimals()}async function D(a,t){if(a.min)return t.query(a.min.build({asset:t.chain.getMinAssetId(a.asset)}));let e=t.chain.getAssetMin(a.asset);if(e){let n=await t.getAssetDecimals(a.asset);return mt(e,n)}return 0n}async function j({transferConfig:a,destinationAddress:t,destinationFee:e,evmSigner:n,polkadot:r,sourceAddress:s}){var O,Q,_,X;let{asset:o,destination:m,source:{chain:c,config:i}}=a,p=G.fromAsset(o,{amount:0n,decimals:await y({address:t,config:i,evmSigner:n,polkadot:r})}),l=(O=i.fee)!=null&&O.asset?G.fromAsset(i.fee.asset,{amount:0n,decimals:await y({address:t,asset:i.fee.asset,config:i,evmSigner:n,polkadot:r})}):p,d=(Q=i.destinationFee)!=null&&Q.asset?G.fromAsset(i.destinationFee.asset,{amount:0n,decimals:await y({address:t,asset:i.destinationFee.asset,config:i,evmSigner:n,polkadot:r})}):p,u=await B({address:s,config:i,evmSigner:n,polkadot:r}),f=await $({address:s,balance:u,feeConfig:i.fee,polkadot:r}),S=i.asset.isEqual(i.destinationFee.asset)?u:await $({address:s,balance:u,feeConfig:i.destinationFee,polkadot:r}),P=await D(i,r),x=(_=i.extrinsic)==null?void 0:_.build({address:t,amount:u,asset:c.getAssetId(o),destination:m.chain,fee:e.amount,feeAsset:c.getAssetId(e),palletInstance:c.getAssetPalletInstance(o),source:c}),v=(X=i.contract)==null?void 0:X.build({address:t,amount:u,asset:c.getAssetId(o),destination:m.chain,fee:e.amount,feeAsset:c.getAssetId(e)}),E=await ft({balance:u,contract:v,decimals:l.decimals,evmSigner:n,extrinsic:x,polkadot:r,sourceAddress:s}),C=p.copyWith({amount:u}),{existentialDeposit:W}=r,R=l.copyWith({amount:E}),Y=l.copyWith({amount:f}),Z=d.copyWith({amount:S}),q=p.copyWith({amount:P}),tt=dt({balanceAmount:C,existentialDeposit:W,feeAmount:R,minAmount:q});return{balance:C,chain:c,destinationFeeBalance:Z,existentialDeposit:W,fee:R,feeBalance:Y,max:tt,min:q}}async function $({address:a,balance:t,feeConfig:e,polkadot:n}){return e?n.query(e.balance.build({address:a,asset:n.chain.getBalanceAssetId(e.asset)})):t}async function ft({balance:a,contract:t,decimals:e,evmSigner:n,extrinsic:r,polkadot:s,sourceAddress:o}){if(t){if(!n)throw new Error("EVM Signer must be provided");return pt(a,t,e,n)}if(r)return lt(a,r,s,o);throw new Error("Either contract or extrinsic must be provided")}async function pt(a,t,e,n){let s=await g(t,n).getFee(a);return ut(s,18,e)}async function lt(a,t,e,n){try{return await e.getFee(n,t)}catch(r){if(a)throw r;return 0n}}function dt({balanceAmount:a,existentialDeposit:t,feeAmount:e,minAmount:n}){let r=a.toBig().minus(n.toBig()).minus(a.isSame(t)?t.toBig():V(0)).minus(a.isSame(e)?e.toBig():V(0));return a.copyWith({amount:r.lt(0)?0n:BigInt(r.toFixed())})}import{ConfigBuilder as U,ConfigService as It}from"@moonbeam-network/xcm-config";import{convertDecimals as xt,toBigInt as J}from"@moonbeam-network/xcm-utils";import A from"big.js";import"@polkadot/api-augment";import{darwiniaPangoro as gt,eq as yt,equilibrium as ht,equilibriumAlphanet as Ct,paring as bt}from"@moonbeam-network/xcm-config";import{AssetAmount as At}from"@moonbeam-network/xcm-types";import{getPolkadotApi as wt}from"@moonbeam-network/xcm-utils";var h=class{api;chain;configService;constructor(t,e,n){this.api=t,this.chain=e,this.configService=n}static async create(t,e){return new h(await wt(t.ws),t,e)}static async createMulti(t,e){return Promise.all(t.map(n=>h.create(n,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==="token"&&[Ct.key,ht.key].includes(this.chain.key))return yt;if(e==="oring"&&this.chain.key===gt.key)return bt;if(!e)throw new Error("No native symbol key found");let n=this.configService.getAsset(e);if(!n)throw new Error(`No asset found for key "${e}" and symbol "${t}"`);return n}get existentialDeposit(){var r,s;let t=(r=this.api.consts.balances)==null?void 0:r.existentialDeposit,e=(s=this.api.consts.eqBalances)==null?void 0:s.existentialDeposit,n=(t==null?void 0:t.toBigInt())||(e==null?void 0:e.toBigInt())||0n;return At.fromAsset(this.asset,{amount:n,decimals:this.decimals})}async getAssetMeta(t){var s,o,m,c,i;let e=((s=this.api.query.assets)==null?void 0:s.metadata)||((o=this.api.query.assetRegistry)==null?void 0:o.metadata)||((m=this.api.query.assetRegistry)==null?void 0:m.currencyMetadatas)||((c=this.api.query.assetRegistry)==null?void 0:c.assetMetadatas)||((i=this.api.query.assetRegistry)==null?void 0:i.assetMetadataMap);if(!e)return;let n=await e(t),r="unwrapOrDefault"in n?n.unwrapOrDefault():n;return{decimals:r.decimals.toNumber(),symbol:r.symbol.toString()}}async getAssetDecimalsFromQuery(t){var r;let e=(r=this.api.query.assetsRegistry)==null?void 0:r.assetDecimals;return e?(await e(t)).unwrapOrDefault().toNumber():void 0}async getAssetDecimals(t){var n;let e=this.chain.getMetadataAssetId(t);return await this.getAssetDecimalsFromQuery(e)||((n=await this.getAssetMeta(e))==null?void 0:n.decimals)||this.chain.getAssetDecimals(t)||this.decimals}async query(t){let e=await this.api.query[t.module][t.func](...t.args);return t.transform(e)}async getFee(t,e){let n=this.api.tx[e.module][e.func],r=e.getArgs(n);return(await n(...r).paymentInfo(t,{nonce:-1})).partialFee.toBigInt()}async transfer(t,e,n){let r=this.api.tx[e.module][e.func],s=e.getArgs(r);return(await r(...s).signAndSend(this.#t(n)?t:n,{nonce:-1,signer:this.#t(n)?n:void 0})).toString()}#t(t){return"signPayload"in t}};import{AssetAmount as L}from"@moonbeam-network/xcm-types";import{toBigInt as St}from"@moonbeam-network/xcm-utils";async function H({transferConfig:a,destinationAddress:t,evmSigner:e,polkadot:n}){let{asset:r,destination:{chain:s,config:o}}=a,m=L.fromAsset(r,{amount:0n,decimals:await y({address:t,config:o,evmSigner:e,polkadot:n})}),c=await B({address:t,config:o,evmSigner:e,polkadot:n}),i=await D(o,n),p=m.copyWith({amount:c}),{existentialDeposit:l}=n,d=await Pt({address:t,config:a,evmSigner:e,polkadot:n}),u=m.copyWith({amount:i});return{balance:p,chain:s,existentialDeposit:l,fee:d,min:u}}async function Pt({address:a,config:t,evmSigner:e,polkadot:n}){let{amount:r,asset:s}=t.source.config.destinationFee,o=await y({address:a,asset:s,config:t.destination.config,evmSigner:e,polkadot:n}),m=L.fromAsset(s,{amount:0n,decimals:o});if(Number.isFinite(r))return m.copyWith({amount:St(r,o)});let c=r.build({api:n.api,asset:n.chain.getAssetId(s)});return m.copyWith({amount:await c.call()})}async function M({configService:a,destinationAddress:t,evmSigner:e,polkadotSigner:n,sourceAddress:r,transferConfig:s}){let[o,m]=await h.createMulti([s.destination.chain,s.source.chain],a),c=await H({destinationAddress:t,evmSigner:e,polkadot:o,transferConfig:s}),i=await Et(m,c.fee),p=await j({destinationAddress:t,destinationFee:i,evmSigner:e,polkadot:m,sourceAddress:r,transferConfig:s});return{destination:c,getEstimate(l){let u=A(J(l,p.balance.decimals).toString()).minus(p.balance.isSame(i)?i.toBig():A(0));return p.balance.copyWith({amount:u.lt(0)?0n:BigInt(u.toFixed())})},isSwapPossible:!0,max:p.max,min:vt(c),source:p,async swap(){return M({configService:a,destinationAddress:r,evmSigner:e,polkadotSigner:n,sourceAddress:t,transferConfig:{...s,destination:s.source,source:s.destination}})},async transfer(l){var v,E;let d=J(l,p.balance.decimals),{asset:u,source:{chain:f,config:S}}=s,P=(v=S.contract)==null?void 0:v.build({address:t,amount:d,asset:f.getAssetId(u),destination:c.chain,fee:i.amount,feeAsset:f.getAssetId(i)}),x=(E=S.extrinsic)==null?void 0:E.build({address:t,amount:d,asset:f.getAssetId(u),destination:c.chain,fee:i.amount,feeAsset:f.getAssetId(i),palletInstance:f.getAssetPalletInstance(u),source:f});if(P){if(!e)throw new Error("EVM Signer must be provided");return g(P,e).transfer().then(C=>typeof C=="object"?C.hash:C)}if(x){if(!n)throw new Error("Polkadot signer must be provided");return m.transfer(r,x,n)}throw new Error("Either contract or extrinsic must be provided")}}}function vt({balance:a,existentialDeposit:t,fee:e,min:n}){let r=A(0).plus(a.isSame(e)?e.toBig():A(0)).plus(a.isSame(t)&&a.toBig().lt(t.toBig())?t.toBig():A(0)).plus(a.toBig().lt(n.toBig())?n.toBig():A(0));return a.copyWith({amount:BigInt(r.toFixed())})}async function Et(a,t){let e=await a.getAssetDecimals(t);return t.decimals===e?t:t.copyWith({amount:xt(t.amount,t.decimals,e),decimals:e})}function $e(a){let t=(a==null?void 0:a.configService)??new It;return{assets(e){let{assets:n,asset:r}=U(t).assets(e);return{assets:n,asset(s){let{sourceChains:o,source:m}=r(s);return{sourceChains:o,source(c){let{destinationChains:i,destination:p}=m(c);return{destinationChains:i,destination(l){return{async accounts(d,u,f){return M({...a,configService:t,destinationAddress:u,evmSigner:(f==null?void 0:f.evmSigner)??(f==null?void 0:f.ethersSigner),sourceAddress:d,transferConfig:p(l).build(),polkadotSigner:f==null?void 0:f.polkadotSigner})}}}}}}}}},async getTransferData({destinationAddress:e,destinationKeyOrChain:n,ethersSigner:r,evmSigner:s,keyOrAsset:o,polkadotSigner:m,sourceAddress:c,sourceKeyOrChain:i}){return M({configService:t,destinationAddress:e,evmSigner:s??r,polkadotSigner:m,sourceAddress:c,transferConfig:U(t).assets().asset(o).source(i).destination(n).build()})}}}export{$e as Sdk,pt as getContractFee,lt as getExtrinsicFee,ft as getFee,$ as getFeeBalances,dt as getMax,j as getSourceData};
+// src/getTransferData/getDestinationData.ts
+import { Parachain as Parachain2 } from "@moonbeam-network/xcm-types";
+import { getSovereignAccountAddresses } from "@moonbeam-network/xcm-utils";
+
+// 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 {
+  createPublicClient,
+  http
+} 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/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
+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,
+  source
+}) {
+  const zero = AssetAmount2.fromChainAsset(destination.getChainAsset(feeAsset), {
+    amount: 0n
+  });
+  if (typeof fee === "number") {
+    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),
+      source
+    });
+    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/getDestinationData.ts
+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,
+    source: route.source.chain,
+    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/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 = await getBalance({
+    address: sourceAddress,
+    asset: feeAsset,
+    builder: route.source.fee.balance,
+    chain: source
+  });
+  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/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 }, statusCallback) {
+      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,
+          statusCallback
+        );
+      }
+      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