@moonbeam-network/xcm-sdk 1.0.0-dev.2 → 1.0.0-dev.200

package/build/index.mjs

@@ -1,2 +1,771 @@
-import{AssetAmount as q}from"@moonbeam-network/xcm-types";import{convertDecimals as U}from"@moonbeam-network/xcm-utils";import W from"big.js";import{Contract as $}from"ethers";var F=[{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 x=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=new $(this.address,F,e)}async getBalance(){return(await this.#e.balanceOf(...this.#t.args)).toBigInt()}};import{Contract as L}from"ethers";var G=[{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 S=class{address="0x0000000000000000000000000000000000000804";#t;#e;#n;constructor(t,e){this.#t=t,this.#n=e,this.#e=new L(this.address,G,e)}async transfer(){return this.#e[this.#t.func](...this.#t.args)}async getFee(t){if(t===0n)return 0n;try{let e=(await this.#e.estimateGas[this.#t.func](...this.#t.args)).toBigInt(),n=await this.getGasPrice();return e*n}catch(e){return console.error(e),0n}}async getGasPrice(){let{gasPrice:t,maxPriorityFeePerGas:e}=await this.#n.getFeeData();return((t==null?void 0:t.toBigInt())||0n)+((e==null?void 0:e.toBigInt())||0n)}};function g(a,t){if(a.module==="Erc20")return new x(a,t);if(a.module==="Xtokens")return new S(a,t);throw new Error(`Contract ${a.module} not found`)}import{CallType as H}from"@moonbeam-network/xcm-builder";import{toBigInt as J}from"@moonbeam-network/xcm-utils";async function B({address:a,config:t,ethersSigner:e,polkadot:n}){let r=t.balance.build({address:a,asset:n.chain.getBalanceAssetId(t.asset)});return r.type===H.Substrate?n.query(r):g(r,e).getBalance()}async function T(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 J(e,n)}return 0n}async function O({transferConfig:a,destinationAddress:t,destinationFee:e,ethersSigner:n,polkadot:r,sourceAddress:s}){var M,E,k;let{asset:i,destination:m,source:{chain:o,config:c}}=a,f=q.fromAsset(i,{amount:0n,decimals:await r.getAssetDecimals(i)}),l=(M=c.fee)!=null&&M.asset?q.fromAsset(c.fee.asset,{amount:0n,decimals:await r.getAssetDecimals(c.fee.asset)}):f,u=await B({address:s,config:c,ethersSigner:n,polkadot:r}),p=await V({address:s,balance:u,config:c,polkadot:r}),A=await T(c,r),b=(E=c.extrinsic)==null?void 0:E.build({address:t,amount:u,asset:o.getAssetId(i),destination:m.chain,fee:e.amount,feeAsset:o.getAssetId(e),palletInstance:o.getAssetPalletInstance(i),source:o}),C=(k=c.contract)==null?void 0:k.build({address:t,amount:u,asset:o.getAssetId(i),destination:m.chain,fee:e.amount,feeAsset:o.getAssetId(e)}),P=await Y({balance:u,contract:C,decimals:l.decimals,ethersSigner:n,extrinsic:b,polkadot:r,sourceAddress:s}),h=f.copyWith({amount:u}),{existentialDeposit:w}=r,D=l.copyWith({amount:P}),z=l.copyWith({amount:p}),v=f.copyWith({amount:A}),N=et({balanceAmount:h,existentialDeposit:w,feeAmount:D,minAmount:v});return{balance:h,chain:o,existentialDeposit:w,fee:D,feeBalance:z,max:N,min:v}}async function V({address:a,balance:t,config:e,polkadot:n}){return e.fee?n.query(e.fee.balance.build({address:a,asset:n.chain.getBalanceAssetId(e.fee.asset)})):t}async function Y({balance:a,contract:t,decimals:e,ethersSigner:n,extrinsic:r,polkadot:s,sourceAddress:i}){if(t){if(!n)throw new Error("Ethers signer must be provided");return Z(a,t,e,n)}if(r)return tt(a,r,s,i);throw new Error("Either contract or extrinsic must be provided")}async function Z(a,t,e,n){let s=await g(t,n).getFee(a);return U(s,18,e)}async function tt(a,t,e,n){try{return await e.getFee(n,t)}catch(r){if(a)throw r;return 0n}}function et({balanceAmount:a,existentialDeposit:t,feeAmount:e,minAmount:n}){let r=a.toBig().minus(n.toBig()).minus(a.isSame(t)?t.toBig():W(0)).minus(a.isSame(e)?e.toBig():W(0));return a.copyWith({amount:r.lt(0)?0n:BigInt(r.toFixed())})}import{ConfigBuilder as K}from"@moonbeam-network/xcm-config";import{convertDecimals as pt,toBigInt as R}from"@moonbeam-network/xcm-utils";import y from"big.js";import"@polkadot/api-augment";import{assetsMap as nt,darwiniaPangoro as at,eq as rt,equilibriumAlphanet as st,paring as it}from"@moonbeam-network/xcm-config";import{AssetAmount as ot}from"@moonbeam-network/xcm-types";import{getPolkadotApi as ct}from"@moonbeam-network/xcm-utils";var d=class{api;chain;constructor(t,e){this.api=t,this.chain=e}static async create(t){return new d(await ct(t.ws),t)}static async createMulti(t){return Promise.all(t.map(d.create))}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"&&this.chain.key===st.key)return rt;if(e==="oring"&&this.chain.key===at.key)return it;if(!e)throw new Error("No native symbol key found");let n=nt.get(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 ot.fromAsset(this.asset,{amount:n,decimals:this.decimals})}async getAssetMeta(t){var s,i,m,o,c;let e=((s=this.api.query.assets)==null?void 0:s.metadata)||((i=this.api.query.assetRegistry)==null?void 0:i.metadata)||((m=this.api.query.assetRegistry)==null?void 0:m.currencyMetadatas)||((o=this.api.query.assetRegistry)==null?void 0:o.assetMetadatas)||((c=this.api.query.assetRegistry)==null?void 0:c.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 getAssetDecimals(t){var e;return((e=await this.getAssetMeta(this.chain.getMetadataAssetId(t)))==null?void 0:e.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 _}from"@moonbeam-network/xcm-types";import{toBigInt as mt}from"@moonbeam-network/xcm-utils";async function Q({transferConfig:a,destinationAddress:t,ethersSigner:e,polkadot:n}){let{asset:r,destination:{chain:s,config:i}}=a,m=_.fromAsset(r,{amount:0n,decimals:await n.getAssetDecimals(r)}),o=await B({address:t,config:i,ethersSigner:e,polkadot:n}),c=await T(i,n),f=m.copyWith({amount:o}),{existentialDeposit:l}=n,u=await ut({config:a,polkadot:n}),p=m.copyWith({amount:c});return{balance:f,chain:s,existentialDeposit:l,fee:u,min:p}}async function ut({config:a,polkadot:t}){let{amount:e,asset:n}=a.source.config.destinationFee,r=await t.getAssetDecimals(n),s=_.fromAsset(n,{amount:0n,decimals:r});if(Number.isFinite(e))return s.copyWith({amount:mt(e,r)});let i=e.build({api:t.api,asset:t.chain.getAssetId(n)});return s.copyWith({amount:await i.call()})}async function I({destinationAddress:a,ethersSigner:t,polkadotSigner:e,sourceAddress:n,transferConfig:r}){if(!t)throw new Error("Ethers signer must be provided");let[s,i]=await d.createMulti([r.destination.chain,r.source.chain]),m=await Q({destinationAddress:a,ethersSigner:t,polkadot:s,transferConfig:r}),o=await lt(i,m.fee),c=await O({destinationAddress:a,destinationFee:o,ethersSigner:t,polkadot:i,sourceAddress:n,transferConfig:r});return{destination:m,getEstimate(f){let u=y(R(f,c.balance.decimals).toString()).minus(c.balance.isSame(o)?o.toBig():y(0));return c.balance.copyWith({amount:u.lt(0)?0n:BigInt(u.toFixed())})},isSwapPossible:!0,max:c.max,min:ft(m),source:c,async swap(){return I({destinationAddress:n,ethersSigner:t,polkadotSigner:e,sourceAddress:a,transferConfig:{...r,destination:r.source,source:r.destination}})},async transfer(f){var P,h;let l=R(f,c.balance.decimals),{asset:u,source:{chain:p,config:A}}=r,b=(P=A.contract)==null?void 0:P.build({address:a,amount:l,asset:p.getAssetId(u),destination:m.chain,fee:o.amount,feeAsset:p.getAssetId(o)}),C=(h=A.extrinsic)==null?void 0:h.build({address:a,amount:l,asset:p.getAssetId(u),destination:m.chain,fee:o.amount,feeAsset:p.getAssetId(o),palletInstance:p.getAssetPalletInstance(u),source:p});if(b){if(!t)throw new Error("Ethers signer must be provided");return g(b,t).transfer().then(w=>w.hash)}if(C){if(!e)throw new Error("Polkadot signer must be provided");return i.transfer(n,C,e)}throw new Error("Either contract or extrinsic must be provided")}}}function ft({balance:a,existentialDeposit:t,fee:e,min:n}){let r=y(0).plus(a.isSame(e)?e.toBig():y(0)).plus(a.isSame(t)&&a.toBig().lt(t.toBig())?t.toBig():y(0)).plus(a.toBig().lt(n.toBig())?n.toBig():y(0));return a.copyWith({amount:BigInt(r.toFixed())})}async function lt(a,t){let e=await a.getAssetDecimals(t);return t.decimals===e?t:t.copyWith({amount:pt(t.amount,t.decimals,e),decimals:e})}function Ce(a){return{assets(t){let{assets:e,asset:n}=K().assets(t);return{assets:e,asset(r){let{sourceChains:s,source:i}=n(r);return{sourceChains:s,source(m){let{destinationChains:o,destination:c}=i(m);return{destinationChains:o,destination(f){return{async accounts(l,u,p){return I({...a,...p,destinationAddress:u,sourceAddress:l,transferConfig:c(f).build()})}}}}}}}}},async getTransferData({destinationAddress:t,destinationKeyOrChain:e,ethersSigner:n,keyOrAsset:r,polkadotSigner:s,sourceAddress:i,sourceKeyOrChain:m}){return I({destinationAddress:t,ethersSigner:n,polkadotSigner:s,sourceAddress:i,transferConfig:K().assets().asset(r).source(m).destination(e).build()})}}}export{Ce as Sdk,Z as getContractFee,tt as getExtrinsicFee,Y as getFee,V as getFeeBalances,et as getMax,O as getSourceData};
+// 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,
+  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/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/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,
+    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/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