@skip-go/client 1.5.3-alpha.0 → 1.5.3

package/dist/esm/chunk-RJ35JBT4.js

@@ -1,2154 +0,0 @@
-import { updateRouteDetails, executeAndSubscribeToRouteStatus } from './chunk-5IXH2QPF.js';
-import { validateCosmosGasBalance } from './chunk-47HN6VKU.js';
-import { getEncodeObjectFromCosmosMessage } from './chunk-KNXMSLOB.js';
-import { getEVMGasAmountForMessage } from './chunk-GV2QOWB4.js';
-import { bignumber_default, BigNumber } from './chunk-JYYCFKB4.js';
-import { GAS_STATION_CHAIN_IDS } from './chunk-YWG4XR5A.js';
-import { getRpcEndpointForChain, accountParser, getSigningStargateClient } from './chunk-SOVU5NCL.js';
-import { chains as chains$1, findFirstWorkingEndpoint, getIsEthermint, getIsInitia } from './chunk-RHGDUD76.js';
-import { messages } from './chunk-IHSSWY3M.js';
-import { route } from './chunk-VWOMKMH2.js';
-import { submitTransaction } from './chunk-HDW6XFWX.js';
-import { trackTransaction } from './chunk-AUNRER4I.js';
-import { venues } from './chunk-FNTPI2AV.js';
-import { ClientState, chains, assets, balances } from './chunk-MYGJGC62.js';
-import { ApiState, toCamel, wait } from './chunk-VGCTTJO7.js';
-import { StargateClient } from '@cosmjs/stargate';
-import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx.js';
-import { isOfflineDirectSigner, makeAuthInfoBytes, makeSignDoc, encodePubkey } from '@cosmjs/proto-signing';
-import { pubkeyType as pubkeyType$1, makeSignDoc as makeSignDoc$1, encodeSecp256k1Pubkey } from '@cosmjs/amino';
-import { fromBase64, toBase64 } from '@cosmjs/encoding';
-import { PubKey } from 'cosmjs-types/cosmos/crypto/secp256k1/keys.js';
-import { Any } from 'cosmjs-types/google/protobuf/any.js';
-import { Int53 } from '@cosmjs/math';
-import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing.js';
-import { defineChain, createPublicClient, fallback, http, isAddress, formatUnits, publicActions, maxUint256 } from 'viem';
-import { PublicKey, Transaction, Connection, LAMPORTS_PER_SOL } from '@solana/web3.js';
-import { bech32m, bech32 } from 'bech32';
-import { arbitrum, avalanche, base, bsc, celo, fantom, filecoin, kava, linea, mainnet, manta, moonbeam, optimism, polygon, polygonMumbai, sepolia, avalancheFuji, baseSepolia, optimismSepolia, arbitrumSepolia, blast, blastSepolia, forma, sei, bscTestnet, fantomTestnet, kavaTestnet, lineaSepolia, mantaSepoliaTestnet } from 'viem/chains';
-
-// src/types/swaggerTypesJson.ts
-var AutopilotActionJson = /* @__PURE__ */ ((AutopilotActionJson2) => {
-  AutopilotActionJson2["LIQUID_STAKE"] = "LIQUID_STAKE";
-  AutopilotActionJson2["CLAIM"] = "CLAIM";
-  return AutopilotActionJson2;
-})(AutopilotActionJson || {});
-var AxelarTransferStateJson = /* @__PURE__ */ ((AxelarTransferStateJson2) => {
-  AxelarTransferStateJson2["AXELAR_TRANSFER_UNKNOWN"] = "AXELAR_TRANSFER_UNKNOWN";
-  AxelarTransferStateJson2["AXELAR_TRANSFER_PENDING_CONFIRMATION"] = "AXELAR_TRANSFER_PENDING_CONFIRMATION";
-  AxelarTransferStateJson2["AXELAR_TRANSFER_PENDING_RECEIPT"] = "AXELAR_TRANSFER_PENDING_RECEIPT";
-  AxelarTransferStateJson2["AXELAR_TRANSFER_SUCCESS"] = "AXELAR_TRANSFER_SUCCESS";
-  AxelarTransferStateJson2["AXELAR_TRANSFER_FAILURE"] = "AXELAR_TRANSFER_FAILURE";
-  return AxelarTransferStateJson2;
-})(AxelarTransferStateJson || {});
-var AxelarTransferTypeJson = /* @__PURE__ */ ((AxelarTransferTypeJson2) => {
-  AxelarTransferTypeJson2["AXELAR_TRANSFER_CONTRACT_CALL_WITH_TOKEN"] = "AXELAR_TRANSFER_CONTRACT_CALL_WITH_TOKEN";
-  AxelarTransferTypeJson2["AXELAR_TRANSFER_SEND_TOKEN"] = "AXELAR_TRANSFER_SEND_TOKEN";
-  return AxelarTransferTypeJson2;
-})(AxelarTransferTypeJson || {});
-var CCTPTransferStateJson = /* @__PURE__ */ ((CCTPTransferStateJson2) => {
-  CCTPTransferStateJson2["CCTP_TRANSFER_UNKNOWN"] = "CCTP_TRANSFER_UNKNOWN";
-  CCTPTransferStateJson2["CCTP_TRANSFER_SENT"] = "CCTP_TRANSFER_SENT";
-  CCTPTransferStateJson2["CCTP_TRANSFER_PENDING_CONFIRMATION"] = "CCTP_TRANSFER_PENDING_CONFIRMATION";
-  CCTPTransferStateJson2["CCTP_TRANSFER_CONFIRMED"] = "CCTP_TRANSFER_CONFIRMED";
-  CCTPTransferStateJson2["CCTP_TRANSFER_RECEIVED"] = "CCTP_TRANSFER_RECEIVED";
-  return CCTPTransferStateJson2;
-})(CCTPTransferStateJson || {});
-var StargateTransferStateJson = /* @__PURE__ */ ((StargateTransferStateJson2) => {
-  StargateTransferStateJson2["STARGATE_TRANSFER_UNKNOWN"] = "STARGATE_TRANSFER_UNKNOWN";
-  StargateTransferStateJson2["STARGATE_TRANSFER_SENT"] = "STARGATE_TRANSFER_SENT";
-  StargateTransferStateJson2["STARGATE_TRANSFER_PENDING_CONFIRMATION"] = "STARGATE_TRANSFER_PENDING_CONFIRMATION";
-  StargateTransferStateJson2["STARGATE_TRANSFER_CONFIRMED"] = "STARGATE_TRANSFER_CONFIRMED";
-  StargateTransferStateJson2["STARGATE_TRANSFER_RECEIVED"] = "STARGATE_TRANSFER_RECEIVED";
-  StargateTransferStateJson2["STARGATE_TRANSFER_FAILED"] = "STARGATE_TRANSFER_FAILED";
-  return StargateTransferStateJson2;
-})(StargateTransferStateJson || {});
-var GoFastTransferStateJson = /* @__PURE__ */ ((GoFastTransferStateJson2) => {
-  GoFastTransferStateJson2["GO_FAST_TRANSFER_UNKNOWN"] = "GO_FAST_TRANSFER_UNKNOWN";
-  GoFastTransferStateJson2["GO_FAST_TRANSFER_SENT"] = "GO_FAST_TRANSFER_SENT";
-  GoFastTransferStateJson2["GO_FAST_POST_ACTION_FAILED"] = "GO_FAST_POST_ACTION_FAILED";
-  GoFastTransferStateJson2["GO_FAST_TRANSFER_TIMEOUT"] = "GO_FAST_TRANSFER_TIMEOUT";
-  GoFastTransferStateJson2["GO_FAST_TRANSFER_FILLED"] = "GO_FAST_TRANSFER_FILLED";
-  GoFastTransferStateJson2["GO_FAST_TRANSFER_REFUNDED"] = "GO_FAST_TRANSFER_REFUNDED";
-  return GoFastTransferStateJson2;
-})(GoFastTransferStateJson || {});
-var BridgeTypeJson = /* @__PURE__ */ ((BridgeTypeJson2) => {
-  BridgeTypeJson2["IBC"] = "IBC";
-  BridgeTypeJson2["AXELAR"] = "AXELAR";
-  BridgeTypeJson2["CCTP"] = "CCTP";
-  BridgeTypeJson2["HYPERLANE"] = "HYPERLANE";
-  BridgeTypeJson2["OPINIT"] = "OPINIT";
-  BridgeTypeJson2["GO_FAST"] = "GO_FAST";
-  BridgeTypeJson2["STARGATE"] = "STARGATE";
-  BridgeTypeJson2["LAYER_ZERO"] = "LAYER_ZERO";
-  BridgeTypeJson2["EUREKA"] = "EUREKA";
-  return BridgeTypeJson2;
-})(BridgeTypeJson || {});
-var ChainTypeJson = /* @__PURE__ */ ((ChainTypeJson2) => {
-  ChainTypeJson2["Cosmos"] = "cosmos";
-  ChainTypeJson2["Evm"] = "evm";
-  ChainTypeJson2["Svm"] = "svm";
-  return ChainTypeJson2;
-})(ChainTypeJson || {});
-var ContractCallWithTokenErrorTypeJson = /* @__PURE__ */ ((ContractCallWithTokenErrorTypeJson2) => {
-  ContractCallWithTokenErrorTypeJson2["CONTRACT_CALL_WITH_TOKEN_EXECUTION_ERROR"] = "CONTRACT_CALL_WITH_TOKEN_EXECUTION_ERROR";
-  return ContractCallWithTokenErrorTypeJson2;
-})(ContractCallWithTokenErrorTypeJson || {});
-var HyperlaneTransferStateJson = /* @__PURE__ */ ((HyperlaneTransferStateJson2) => {
-  HyperlaneTransferStateJson2["HYPERLANE_TRANSFER_UNKNOWN"] = "HYPERLANE_TRANSFER_UNKNOWN";
-  HyperlaneTransferStateJson2["HYPERLANE_TRANSFER_SENT"] = "HYPERLANE_TRANSFER_SENT";
-  HyperlaneTransferStateJson2["HYPERLANE_TRANSFER_FAILED"] = "HYPERLANE_TRANSFER_FAILED";
-  HyperlaneTransferStateJson2["HYPERLANE_TRANSFER_RECEIVED"] = "HYPERLANE_TRANSFER_RECEIVED";
-  return HyperlaneTransferStateJson2;
-})(HyperlaneTransferStateJson || {});
-var PacketErrorTypeJson = /* @__PURE__ */ ((PacketErrorTypeJson2) => {
-  PacketErrorTypeJson2["PACKET_ERROR_UNKNOWN"] = "PACKET_ERROR_UNKNOWN";
-  PacketErrorTypeJson2["PACKET_ERROR_ACKNOWLEDGEMENT"] = "PACKET_ERROR_ACKNOWLEDGEMENT";
-  PacketErrorTypeJson2["PACKET_ERROR_TIMEOUT"] = "PACKET_ERROR_TIMEOUT";
-  return PacketErrorTypeJson2;
-})(PacketErrorTypeJson || {});
-var ReasonJson = /* @__PURE__ */ ((ReasonJson2) => {
-  ReasonJson2["UNKNOWN"] = "UNKNOWN";
-  ReasonJson2["MOST_LIQUID"] = "MOST_LIQUID";
-  ReasonJson2["BASE_TOKEN"] = "BASE_TOKEN";
-  ReasonJson2["DIRECT"] = "DIRECT";
-  return ReasonJson2;
-})(ReasonJson || {});
-var RoutePriceWarningTypeJson = /* @__PURE__ */ ((RoutePriceWarningTypeJson2) => {
-  RoutePriceWarningTypeJson2["LOW_INFO_WARNING"] = "LOW_INFO_WARNING";
-  RoutePriceWarningTypeJson2["BAD_PRICE_WARNING"] = "BAD_PRICE_WARNING";
-  return RoutePriceWarningTypeJson2;
-})(RoutePriceWarningTypeJson || {});
-var SendTokenErrorTypeJson = /* @__PURE__ */ ((SendTokenErrorTypeJson2) => {
-  SendTokenErrorTypeJson2["SEND_TOKEN_EXECUTION_ERROR"] = "SEND_TOKEN_EXECUTION_ERROR";
-  return SendTokenErrorTypeJson2;
-})(SendTokenErrorTypeJson || {});
-var StatusErrorTypeJson = /* @__PURE__ */ ((StatusErrorTypeJson2) => {
-  StatusErrorTypeJson2["STATUS_ERROR_UNKNOWN"] = "STATUS_ERROR_UNKNOWN";
-  StatusErrorTypeJson2["STATUS_ERROR_TRANSACTION_EXECUTION"] = "STATUS_ERROR_TRANSACTION_EXECUTION";
-  StatusErrorTypeJson2["STATUS_ERROR_INDEXING"] = "STATUS_ERROR_INDEXING";
-  StatusErrorTypeJson2["STATUS_ERROR_TRANSFER"] = "STATUS_ERROR_TRANSFER";
-  return StatusErrorTypeJson2;
-})(StatusErrorTypeJson || {});
-var TransactionStateJson = /* @__PURE__ */ ((TransactionStateJson2) => {
-  TransactionStateJson2["STATE_SUBMITTED"] = "STATE_SUBMITTED";
-  TransactionStateJson2["STATE_PENDING"] = "STATE_PENDING";
-  TransactionStateJson2["STATE_ABANDONED"] = "STATE_ABANDONED";
-  TransactionStateJson2["STATE_COMPLETED_SUCCESS"] = "STATE_COMPLETED_SUCCESS";
-  TransactionStateJson2["STATE_COMPLETED_ERROR"] = "STATE_COMPLETED_ERROR";
-  TransactionStateJson2["STATE_PENDING_ERROR"] = "STATE_PENDING_ERROR";
-  return TransactionStateJson2;
-})(TransactionStateJson || {});
-var OPInitTransferStateJson = /* @__PURE__ */ ((OPInitTransferStateJson2) => {
-  OPInitTransferStateJson2["OPINIT_TRANSFER_UNKNOWN"] = "OPINIT_TRANSFER_UNKNOWN";
-  OPInitTransferStateJson2["OPINIT_TRANSFER_SENT"] = "OPINIT_TRANSFER_SENT";
-  OPInitTransferStateJson2["OPINIT_TRANSFER_RECEIVED"] = "OPINIT_TRANSFER_RECEIVED";
-  return OPInitTransferStateJson2;
-})(OPInitTransferStateJson || {});
-var LayerZeroTransferStateJson = /* @__PURE__ */ ((LayerZeroTransferStateJson2) => {
-  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_UNKNOWN"] = "LAYER_ZERO_TRANSFER_UNKNOWN";
-  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_SENT"] = "LAYER_ZERO_TRANSFER_SENT";
-  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_WAITING_FOR_COMPOSE"] = "LAYER_ZERO_TRANSFER_WAITING_FOR_COMPOSE";
-  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_RECEIVED"] = "LAYER_ZERO_TRANSFER_RECEIVED";
-  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_FAILED"] = "LAYER_ZERO_TRANSFER_FAILED";
-  return LayerZeroTransferStateJson2;
-})(LayerZeroTransferStateJson || {});
-var TransferStateJson = /* @__PURE__ */ ((TransferStateJson2) => {
-  TransferStateJson2["TRANSFER_UNKNOWN"] = "TRANSFER_UNKNOWN";
-  TransferStateJson2["TRANSFER_PENDING"] = "TRANSFER_PENDING";
-  TransferStateJson2["TRANSFER_RECEIVED"] = "TRANSFER_RECEIVED";
-  TransferStateJson2["TRANSFER_SUCCESS"] = "TRANSFER_SUCCESS";
-  TransferStateJson2["TRANSFER_FAILURE"] = "TRANSFER_FAILURE";
-  return TransferStateJson2;
-})(TransferStateJson || {});
-var FeeTypeJson = /* @__PURE__ */ ((FeeTypeJson2) => {
-  FeeTypeJson2["SMART_RELAY"] = "SMART_RELAY";
-  return FeeTypeJson2;
-})(FeeTypeJson || {});
-var FeeBehaviorJson = /* @__PURE__ */ ((FeeBehaviorJson2) => {
-  FeeBehaviorJson2["FEE_BEHAVIOR_DEDUCTED"] = "FEE_BEHAVIOR_DEDUCTED";
-  FeeBehaviorJson2["FEE_BEHAVIOR_ADDITIONAL"] = "FEE_BEHAVIOR_ADDITIONAL";
-  return FeeBehaviorJson2;
-})(FeeBehaviorJson || {});
-
-// src/private-functions/getRestEndpointForChain.ts
-var getRestEndpointForChain = async (chainId) => {
-  if (ClientState.endpointOptions.getRestEndpointForChain) {
-    return ClientState.endpointOptions.getRestEndpointForChain(chainId);
-  }
-  if (ClientState.endpointOptions.endpoints && ClientState.endpointOptions.endpoints[chainId]) {
-    const endpointOptions = ClientState.endpointOptions.endpoints[chainId];
-    if (endpointOptions?.rest) {
-      return endpointOptions.rest;
-    }
-  }
-  const chain = chains$1().find((chain2) => chain2.chainId === chainId);
-  if (!chain) {
-    throw new Error(
-      `getRestEndpointForChain error: failed to find chain id '${chainId}' in registry`
-    );
-  }
-  if (chain.apis?.rest?.length === 0 || !chain.apis?.rest) {
-    throw new Error(
-      `getRestEndpointForChain error: failed to find REST endpoint for chain id '${chainId}'`
-    );
-  }
-  const endpoints = chain.apis?.rest?.map((api) => api.address);
-  const endpoint = await findFirstWorkingEndpoint(endpoints, "rest");
-  if (!endpoint) {
-    throw new Error(
-      `getRestEndpointForChain error: failed to find REST endpoint for chain id '${chainId}'`
-    );
-  }
-  return endpoint;
-};
-
-// src/private-functions/getAccountNumberAndSequence.ts
-var getAccountNumberAndSequence = async (address, chainId) => {
-  if (chainId.includes("dymension")) {
-    return getAccountNumberAndSequenceFromDymension(address, chainId);
-  }
-  const endpoint = await getRpcEndpointForChain(chainId);
-  const client = ClientState.signingStargateClientByChainId[chainId] ?? await StargateClient.connect(endpoint, {
-    accountParser
-  });
-  const account = await client.getAccount(address);
-  if (!account) {
-    throw new Error("getAccountNumberAndSequence: failed to retrieve account");
-  }
-  client.disconnect();
-  return {
-    accountNumber: account.accountNumber,
-    sequence: account.sequence
-  };
-};
-var getAccountNumberAndSequenceFromDymension = async (address, chainId) => {
-  const endpoint = await getRestEndpointForChain(chainId);
-  const res = await fetch(
-    `${endpoint}/cosmos/auth/v1beta1/accounts/${address}`,
-    {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    }
-  );
-  if (!res.ok) {
-    throw new Error(`Failed to fetch account data: ${res.statusText}`);
-  }
-  const jsonResponse = await res.json();
-  const response = toCamel(jsonResponse);
-  let sequence = 0;
-  let accountNumber = 0;
-  if (response.account.baseAccount) {
-    sequence = response.account.baseAccount.sequence;
-    accountNumber = response.account.baseAccount.accountNumber;
-  } else {
-    sequence = response.account.sequence;
-    accountNumber = response.account.accountNumber;
-  }
-  return {
-    accountNumber,
-    sequence
-  };
-};
-var pubkeyType = {
-  ethsecp256k1: "ethermint/PubKeyEthSecp256k1",
-  ...pubkeyType$1
-};
-
-// src/amino/encoding.ts
-function encodeEthSecp256k1Pubkey(pubkey) {
-  if (pubkey.length !== 33 || pubkey[0] !== 2 && pubkey[0] !== 3) {
-    throw new Error(
-      "Public key must be compressed secp256k1, i.e. 33 bytes starting with 0x02 or 0x03"
-    );
-  }
-  return {
-    type: pubkeyType.ethsecp256k1,
-    value: toBase64(pubkey)
-  };
-}
-
-// src/proto-signing/pubkey.ts
-function makePubkeyAnyFromAccount(account, chainId) {
-  const isEthermint = getIsEthermint(chainId);
-  const pubkey = isEthermint ? encodeEthSecp256k1Pubkey(account.pubkey) : encodeSecp256k1Pubkey(account.pubkey);
-  const pubkeyAny = encodePubkeyToAny(pubkey, chainId, isEthermint);
-  return pubkeyAny;
-}
-function encodePubkeyToAny(pubkey, chainId, isEthermint) {
-  if (isEthermint) {
-    const pubkeyProto = PubKey.fromPartial({
-      key: fromBase64(pubkey.value)
-    });
-    let typeUrl = "";
-    if (chainId?.includes("injective")) {
-      typeUrl = "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
-    } else {
-      typeUrl = "/ethermint.crypto.v1.ethsecp256k1.PubKey";
-    }
-    return Any.fromPartial({
-      typeUrl,
-      value: Uint8Array.from(PubKey.encode(pubkeyProto).finish())
-    });
-  } else {
-    const isInitia = getIsInitia(chainId);
-    const pubkeyProto = PubKey.fromPartial({
-      key: fromBase64(pubkey.value)
-    });
-    if (isInitia) {
-      return Any.fromPartial({
-        typeUrl: "/initia.crypto.v1beta1.ethsecp256k1.PubKey",
-        value: Uint8Array.from(PubKey.encode(pubkeyProto).finish())
-      });
-    }
-    return encodePubkey(pubkey);
-  }
-}
-var signCosmosMessageDirect = async (options) => {
-  const {
-    signer,
-    signerAddress,
-    chainId,
-    cosmosMsgs,
-    fee,
-    signerData: { accountNumber, sequence, chainId: signerChainId }
-  } = options;
-  const accounts = await signer.getAccounts();
-  const accountFromSigner = accounts.find((account) => account.address === signerAddress);
-  if (!accountFromSigner) {
-    throw new Error("signCosmosMessageDirect error: failed to retrieve account from signer");
-  }
-  const messages2 = cosmosMsgs.map((cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg));
-  const txBodyEncodeObject = {
-    typeUrl: "/cosmos.tx.v1beta1.TxBody",
-    value: {
-      messages: messages2
-    }
-  };
-  const txBodyBytes = ClientState.registry.encode(txBodyEncodeObject);
-  const gasLimit = Int53.fromString(fee.gas).toNumber();
-  const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainId);
-  const authInfoBytes = makeAuthInfoBytes(
-    [{ pubkey: pubkeyAny, sequence }],
-    fee.amount,
-    gasLimit,
-    fee.granter,
-    fee.payer
-  );
-  const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber);
-  const { signature, signed } = await signer.signDirect(signerAddress, signDoc);
-  return TxRaw.fromPartial({
-    bodyBytes: signed.bodyBytes,
-    authInfoBytes: signed.authInfoBytes,
-    signatures: [fromBase64(signature.signature)]
-  });
-};
-var signCosmosMessageAmino = async (options) => {
-  const {
-    signer,
-    signerAddress,
-    chainId,
-    cosmosMsgs,
-    fee,
-    signerData: { accountNumber, sequence, chainId: signerChainId }
-  } = options;
-  const accounts = await signer.getAccounts();
-  const accountFromSigner = accounts.find(
-    (account) => account.address === signerAddress
-  );
-  if (!accountFromSigner) {
-    throw new Error(
-      "signCosmosMessageAmino: failed to retrieve account from signer"
-    );
-  }
-  const messages2 = cosmosMsgs.map(
-    (cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg)
-  );
-  const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
-  const msgs = messages2.map((msg) => ClientState.aminoTypes.toAmino(msg));
-  const signDoc = makeSignDoc$1(
-    msgs,
-    fee,
-    signerChainId,
-    "",
-    accountNumber,
-    sequence
-  );
-  const { signature, signed } = await signer.signAmino(signerAddress, signDoc);
-  const signedTxBody = {
-    messages: signed.msgs.map((msg) => ClientState.aminoTypes.fromAmino(msg)),
-    memo: signed.memo
-  };
-  signedTxBody.messages[0].value.memo = messages2[0].value.memo;
-  const signedTxBodyEncodeObject = {
-    typeUrl: "/cosmos.tx.v1beta1.TxBody",
-    value: signedTxBody
-  };
-  const signedTxBodyBytes = ClientState.registry.encode(
-    signedTxBodyEncodeObject
-  );
-  const signedGasLimit = Int53.fromString(signed.fee.gas).toNumber();
-  const signedSequence = Int53.fromString(signed.sequence).toNumber();
-  const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainId);
-  const signedAuthInfoBytes = makeAuthInfoBytes(
-    [{ pubkey: pubkeyAny, sequence: signedSequence }],
-    signed.fee.amount,
-    signedGasLimit,
-    signed.fee.granter,
-    signed.fee.payer,
-    signMode
-  );
-  return TxRaw.fromPartial({
-    bodyBytes: signedTxBodyBytes,
-    authInfoBytes: signedAuthInfoBytes,
-    signatures: [fromBase64(signature.signature)]
-  });
-};
-
-// src/private-functions/cosmos/signCosmosTransaction.ts
-var signCosmosTransaction = async ({
-  tx,
-  options,
-  index,
-  routeId
-}) => {
-  const { userAddresses } = options;
-  if (tx === void 0) {
-    throw new Error("executeCosmosTransaction error: tx is undefined");
-  }
-  const chainId = tx.cosmosTx?.chainId;
-  const messages2 = tx.cosmosTx?.msgs;
-  const currentUserAddress = userAddresses.find((x) => x.chainId === tx.cosmosTx?.chainId)?.address;
-  const gasArray = ClientState.validateGasResults;
-  const gas = gasArray?.find((gas2) => gas2?.error !== null && gas2?.error !== void 0);
-  if (typeof gas?.error === "string") {
-    throw new Error(gas?.error);
-  }
-  const gasUsed = gasArray?.[index];
-  if (!gasUsed) {
-    throw new Error(`executeRoute error: invalid gas at index ${index}`);
-  }
-  if (chainId === void 0) {
-    throw new Error("no chainId found for tx");
-  }
-  if (messages2 === void 0) {
-    throw new Error("no messages found for tx");
-  }
-  const { signer } = await getSigningStargateClient({
-    chainId,
-    getOfflineSigner: options?.getCosmosSigner
-  });
-  if (!currentUserAddress) {
-    throw new Error(
-      `executeCosmosTransaction error: invalid address for chain '${tx.cosmosTx?.chainId}'`
-    );
-  }
-  const accounts = await signer.getAccounts();
-  const accountFromSigner = accounts.find((account) => account.address === currentUserAddress);
-  if (!accountFromSigner) {
-    throw new Error("executeCosmosTransaction error: failed to retrieve account from signer");
-  }
-  const fee = gasUsed?.fee;
-  if (!fee) {
-    throw new Error("executeCosmosTransaction error: failed to retrieve fee from gas");
-  }
-  const { accountNumber, sequence } = await getAccountNumberAndSequence(
-    currentUserAddress,
-    chainId
-  );
-  let rawTx;
-  const commonRawTxBody = {
-    signerAddress: currentUserAddress,
-    chainId,
-    cosmosMsgs: messages2,
-    fee,
-    signerData: {
-      accountNumber,
-      sequence,
-      chainId
-    }
-  };
-  options.onTransactionSignRequested?.({
-    chainId,
-    txIndex: index,
-    signerAddress: currentUserAddress
-  });
-  updateRouteDetails({
-    status: "signing",
-    routeId,
-    options
-  });
-  if (isOfflineDirectSigner(signer)) {
-    rawTx = await signCosmosMessageDirect({
-      ...commonRawTxBody,
-      signer
-    });
-  } else {
-    rawTx = await signCosmosMessageAmino({ ...commonRawTxBody, signer });
-  }
-  options?.onTransactionSigned?.({
-    chainId
-  });
-  updateRouteDetails({
-    status: "pending",
-    routeId,
-    options
-  });
-  const txBytes = TxRaw.encode(rawTx).finish();
-  const rawTxBase64 = Buffer.from(txBytes).toString("base64");
-  return rawTxBase64;
-};
-
-// src/private-functions/cosmos/executeCosmosTransaction.ts
-var executeCosmosTransaction = async ({
-  tx,
-  options,
-  index,
-  routeId
-}) => {
-  if (tx === void 0) {
-    throw new Error("executeCosmosTransaction error: tx is undefined");
-  }
-  const rawTxBase64 = await signCosmosTransaction({
-    tx,
-    options,
-    index,
-    routeId
-  });
-  const chainId = tx.cosmosTx?.chainId;
-  const txResponse = await submitTransaction({
-    chainId,
-    tx: rawTxBase64
-  });
-  return {
-    chainId: tx?.cosmosTx?.chainId ?? "",
-    txHash: txResponse?.txHash ?? "",
-    explorerLink: txResponse?.explorerLink ?? ""
-  };
-};
-function createAbi(abi) {
-  return abi;
-}
-var erc20ABI = /* @__PURE__ */ createAbi([
-  {
-    type: "event",
-    name: "Approval",
-    inputs: [
-      {
-        indexed: true,
-        name: "owner",
-        type: "address"
-      },
-      {
-        indexed: true,
-        name: "spender",
-        type: "address"
-      },
-      {
-        indexed: false,
-        name: "value",
-        type: "uint256"
-      }
-    ]
-  },
-  {
-    type: "event",
-    name: "Transfer",
-    inputs: [
-      {
-        indexed: true,
-        name: "from",
-        type: "address"
-      },
-      {
-        indexed: true,
-        name: "to",
-        type: "address"
-      },
-      {
-        indexed: false,
-        name: "value",
-        type: "uint256"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "allowance",
-    stateMutability: "view",
-    inputs: [
-      {
-        name: "owner",
-        type: "address"
-      },
-      {
-        name: "spender",
-        type: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "approve",
-    stateMutability: "nonpayable",
-    inputs: [
-      {
-        name: "spender",
-        type: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    stateMutability: "view",
-    inputs: [
-      {
-        name: "account",
-        type: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "decimals",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint8"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "name",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "string"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "symbol",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "string"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "totalSupply",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint256"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "transfer",
-    stateMutability: "nonpayable",
-    inputs: [
-      {
-        name: "recipient",
-        type: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool"
-      }
-    ]
-  },
-  {
-    type: "function",
-    name: "transferFrom",
-    stateMutability: "nonpayable",
-    inputs: [
-      {
-        name: "sender",
-        type: "address"
-      },
-      {
-        name: "recipient",
-        type: "address"
-      },
-      {
-        name: "amount",
-        type: "uint256"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bool"
-      }
-    ]
-  }
-]);
-
-// src/private-functions/evm/executeEvmTransaction.ts
-var executeEvmTransaction = async (message, options, index, routeId) => {
-  const gasArray = ClientState.validateGasResults;
-  const gas = gasArray?.find((gas2) => gas2?.error !== null && gas2?.error !== void 0);
-  if (typeof gas?.error === "string") {
-    throw new Error(gas?.error);
-  }
-  const { evmTx } = message;
-  const getEvmSigner = options.getEvmSigner;
-  if (!getEvmSigner) {
-    throw new Error("executeEVMTransaction error: getEvmSigner is not provided");
-  }
-  if (!evmTx?.chainId) {
-    throw new Error("chain id not found in evmTx");
-  }
-  const evmSigner = await getEvmSigner(evmTx.chainId);
-  if (!evmSigner.account) {
-    throw new Error("executeEVMTransaction error: failed to retrieve account from signer");
-  }
-  if (!evmTx.chainId) {
-    throw new Error("executeEVMTransaction error: chainId not found for evmTx");
-  }
-  if (!evmTx.value && evmTx.value !== "") {
-    throw new Error("executeEVMTransaction error: no value found in evmTx");
-  }
-  const { onApproveAllowance, onTransactionSigned, bypassApprovalCheck, useUnlimitedApproval } = options;
-  const extendedSigner = evmSigner.extend(publicActions);
-  if (!bypassApprovalCheck && evmTx.requiredErc20Approvals) {
-    for (const requiredApproval of evmTx.requiredErc20Approvals) {
-      const allowance = await extendedSigner.readContract({
-        address: requiredApproval.tokenContract,
-        abi: erc20ABI,
-        functionName: "allowance",
-        args: [
-          evmSigner.account.address,
-          requiredApproval.spender
-        ]
-      });
-      if (!requiredApproval.amount) {
-        throw new Error("executeEVMTransaction error: no amount found in a requiredApproval");
-      }
-      if (allowance > BigInt(requiredApproval.amount)) {
-        continue;
-      }
-      onApproveAllowance?.({
-        status: "pending",
-        allowance: requiredApproval
-      });
-      updateRouteDetails({
-        status: "allowance",
-        routeId,
-        options
-      });
-      const txHash2 = await extendedSigner.writeContract({
-        account: evmSigner.account,
-        address: requiredApproval.tokenContract,
-        abi: erc20ABI,
-        functionName: "approve",
-        args: [
-          requiredApproval.spender,
-          useUnlimitedApproval ? maxUint256 : BigInt(requiredApproval.amount) + BigInt(1e3)
-        ],
-        chain: evmSigner.chain
-      });
-      const receipt2 = await extendedSigner.waitForTransactionReceipt({
-        hash: txHash2
-      });
-      if (receipt2.status === "reverted") {
-        throw new Error(
-          `executeEVMTransaction error: evm tx reverted for hash ${receipt2.transactionHash}`
-        );
-      }
-    }
-    onApproveAllowance?.({
-      status: "completed"
-    });
-  }
-  options?.onTransactionSignRequested?.({
-    chainId: evmTx.chainId,
-    signerAddress: evmSigner.account.address,
-    txIndex: index
-  });
-  updateRouteDetails({
-    status: "signing",
-    routeId,
-    options
-  });
-  const txHash = await extendedSigner.sendTransaction({
-    account: evmSigner.account,
-    to: evmTx.to,
-    data: `0x${evmTx.data}`,
-    chain: evmSigner.chain,
-    value: evmTx.value === "" ? void 0 : BigInt(evmTx.value)
-  });
-  updateRouteDetails({
-    status: "pending",
-    routeId,
-    options
-  });
-  onTransactionSigned?.({
-    chainId: evmTx.chainId
-  });
-  const receipt = await extendedSigner.waitForTransactionReceipt({
-    hash: txHash
-  });
-  return receipt;
-};
-var signSvmTransaction = async ({
-  tx,
-  options,
-  index,
-  routeId
-}) => {
-  const gasArray = ClientState.validateGasResults;
-  if (tx === void 0) {
-    throw new Error("executeSvmTransaction error: tx is undefined");
-  }
-  const gas = gasArray?.find(
-    (gas2) => gas2?.error !== null && gas2?.error !== void 0
-  );
-  if (typeof gas?.error === "string") {
-    throw new Error(gas?.error);
-  }
-  const svmTx = tx?.svmTx;
-  const getSvmSigner = options?.getSvmSigner;
-  if (!getSvmSigner) {
-    throw new Error(
-      "executeSvmTransaction error: getSvmSigner is not provided"
-    );
-  }
-  const signer = await getSvmSigner();
-  if (!svmTx?.chainId) {
-    throw new Error("executeSvmTransaction error: chainId not found in svmTx");
-  }
-  const txBuffer = Buffer.from(svmTx.tx ?? "", "base64");
-  const transaction = Transaction.from(txBuffer);
-  if (options.svmFeePayer) {
-    const message = transaction.serializeMessage();
-    const resSignTx = await options.svmFeePayer.signTransaction(message);
-    transaction.addSignature(
-      new PublicKey(options.svmFeePayer.address),
-      Buffer.from(resSignTx)
-    );
-  }
-  if (!("signTransaction" in signer)) return;
-  options?.onTransactionSignRequested?.({
-    chainId: svmTx.chainId,
-    signerAddress: signer.publicKey?.toBase58(),
-    txIndex: index
-  });
-  updateRouteDetails({
-    status: "signing",
-    routeId,
-    options
-  });
-  const signedTx = await signer.signTransaction(transaction);
-  options?.onTransactionSigned?.({ chainId: svmTx.chainId });
-  updateRouteDetails({
-    status: "pending",
-    routeId,
-    options
-  });
-  const serializedTx = signedTx.serialize();
-  return serializedTx;
-};
-
-// src/private-functions/svm/executeSvmTransaction.ts
-var executeSvmTransaction = async (tx, options, index, routeId) => {
-  const svmTx = tx?.svmTx;
-  if (!svmTx?.chainId) {
-    throw new Error("executeSvmTransaction error: chainId not found in svmTx");
-  }
-  const signedTx = await signSvmTransaction({ tx, options, index, routeId });
-  if (!signedTx) {
-    throw new Error("executeSvmTransaction error: signedTx is undefined");
-  }
-  const endpoint = await getRpcEndpointForChain(svmTx.chainId);
-  const connection = new Connection(endpoint);
-  let signature;
-  const submitTxResponse = await submitTransaction({
-    chainId: svmTx.chainId,
-    tx: signedTx.toString("base64")
-  });
-  signature = submitTxResponse?.txHash;
-  const rpcSig = await connection.sendRawTransaction(signedTx, {
-    preflightCommitment: "confirmed",
-    maxRetries: 5
-  });
-  signature = rpcSig;
-  if (!signature) {
-    throw new Error("executeSvmTransaction error: signature not found");
-  }
-  let getStatusCount = 0;
-  let errorCount = 0;
-  while (true) {
-    try {
-      const status = await connection.getSignatureStatus(signature, {
-        searchTransactionHistory: true
-      });
-      if (status?.value?.confirmationStatus === "confirmed") {
-        return {
-          chainId: svmTx.chainId,
-          txHash: signature,
-          explorerLink: submitTxResponse?.explorerLink ?? ""
-        };
-      }
-      if (getStatusCount > 12) {
-        await wait(3e3);
-        throw new Error(
-          `executeSvmTransaction error: waiting finalized status timed out for ${signature}`
-        );
-      }
-      getStatusCount++;
-      await wait(3e3);
-    } catch (error) {
-      errorCount++;
-      if (errorCount > 12) {
-        throw error;
-      }
-    }
-  }
-};
-var validateEvmTokenApproval = async ({
-  requiredErc20Approvals,
-  signer,
-  chain,
-  gasBalance,
-  tx,
-  useUnlimitedApproval
-}) => {
-  if (!signer.account?.address) {
-    throw new Error("validateEvmGasBalance: Signer address not found");
-  }
-  for (const requiredApproval of requiredErc20Approvals) {
-    const extendedSigner = signer.extend(publicActions);
-    const allowance = await extendedSigner.readContract({
-      address: requiredApproval.tokenContract,
-      abi: erc20ABI,
-      functionName: "allowance",
-      args: [signer.account?.address, requiredApproval.spender]
-    });
-    if (allowance > BigInt(requiredApproval.amount)) {
-      continue;
-    }
-    const fee = await extendedSigner.estimateFeesPerGas();
-    const allowanceGasFee = BigInt(fee.maxFeePerGas) * BigInt(1e5);
-    if (!gasBalance) {
-      const chainAssets = (await ClientState.getSkipAssets({ chainId: tx.chainId }))[tx.chainId];
-      const nativeAsset = chainAssets?.find((x) => x.denom.includes("-native"));
-      const zeroAddressAsset = chainAssets?.find(
-        (x) => x.denom.toLowerCase() === "0x0000000000000000000000000000000000000000"
-      );
-      const asset = nativeAsset || zeroAddressAsset;
-      if (!asset?.decimals) {
-        throw new Error(
-          `Insufficient balance for gas on ${chain.prettyName}. Need ${allowanceGasFee} gwei.`
-        );
-      }
-      const formattedGasAmount = formatUnits(allowanceGasFee, asset?.decimals);
-      throw new Error(
-        `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol}.`
-      );
-    }
-    if (BigNumber(gasBalance.amount).lt(Number(allowanceGasFee))) {
-      const chainAssets = (await ClientState.getSkipAssets({ chainId: tx.chainId }))[tx.chainId];
-      const asset = chainAssets?.find(
-        (x) => x.denom.includes("-native") || x.denom.toLowerCase() === "0x0000000000000000000000000000000000000000"
-      );
-      if (!asset?.decimals) {
-        return {
-          error: `Insufficient balance for gas on ${chain.prettyName}. Need ${allowanceGasFee} gwei but only have ${gasBalance.amount} gwei.`,
-          asset: null,
-          fee: null
-        };
-      }
-      const formattedGasAmount = formatUnits(allowanceGasFee, asset?.decimals);
-      return {
-        error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol} but only have ${gasBalance.formattedAmount} ${asset.symbol}.`,
-        asset: null,
-        fee: null
-      };
-    }
-    const txHash = await extendedSigner.writeContract({
-      account: signer.account,
-      address: requiredApproval.tokenContract,
-      abi: erc20ABI,
-      functionName: "approve",
-      args: [
-        requiredApproval.spender,
-        useUnlimitedApproval ? maxUint256 : BigInt(requiredApproval.amount) + BigInt(1e3)
-      ],
-      chain: signer.chain
-    });
-    const receipt = await extendedSigner.waitForTransactionReceipt({
-      hash: txHash
-    });
-    if (receipt.status === "reverted") {
-      throw new Error(
-        `executeEVMTransaction error: evm tx reverted for hash ${receipt.transactionHash}`
-      );
-    }
-  }
-};
-
-// src/private-functions/evm/validateEvmGasBalance.ts
-var validateEvmGasBalance = async ({
-  signer,
-  tx,
-  getFallbackGasAmount,
-  useUnlimitedApproval,
-  bypassApprovalCheck
-}) => {
-  const chainId = tx?.chainId ?? "";
-  const skipAssets = (await ClientState.getSkipAssets({ chainId }))?.[chainId];
-  const skipChains = await ClientState.getSkipChains();
-  const chain = skipChains?.find?.((chain2) => chain2.chainId === chainId);
-  if (!chain) {
-    throw new Error(`failed to find chain for chainId: '${chainId}'`);
-  }
-  if (!signer.account?.address) {
-    throw new Error("validateEvmGasBalance: Signer address not found");
-  }
-  const skipBalances = (await balances({
-    chains: {
-      [tx?.chainId ?? ""]: {
-        address: signer.account?.address
-      }
-    }
-  }))?.chains?.[tx?.chainId ?? ""]?.denoms;
-  const nativeGasBalance = skipBalances && Object.entries(skipBalances).find(([denom]) => denom.includes("-native"))?.[1];
-  const zeroAddressGasBalance = skipBalances && Object.entries(skipBalances).find(
-    ([denom]) => denom.toLowerCase() === "0x0000000000000000000000000000000000000000"
-  )?.[1];
-  const gasBalance = nativeGasBalance || zeroAddressGasBalance;
-  const { requiredErc20Approvals } = tx;
-  if (!bypassApprovalCheck && requiredErc20Approvals) {
-    try {
-      await validateEvmTokenApproval({
-        requiredErc20Approvals,
-        signer,
-        chain,
-        gasBalance,
-        tx,
-        useUnlimitedApproval
-      });
-    } catch (error) {
-      const err = error;
-      return {
-        error: err.message,
-        asset: null,
-        fee: null
-      };
-    }
-  }
-  const gasAmount = await getEVMGasAmountForMessage(signer, tx, getFallbackGasAmount);
-  if (!gasBalance) {
-    const nativeAsset = skipAssets?.find((x) => x.denom?.includes("-native"));
-    const zeroAddressAsset = skipAssets?.find(
-      (x) => x.denom?.toLowerCase() === "0x0000000000000000000000000000000000000000"
-    );
-    const asset = nativeAsset || zeroAddressAsset;
-    if (!asset?.decimals) {
-      return {
-        error: `Insufficient balance for gas on ${chain.prettyName}. Need ${gasAmount} gwei.`,
-        asset: null,
-        fee: null
-      };
-    }
-    const formattedGasAmount = formatUnits(gasAmount, asset?.decimals);
-    return {
-      error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol}.`,
-      asset: null,
-      fee: null
-    };
-  }
-  if (BigNumber(gasBalance.amount ?? "").lt(Number(gasAmount))) {
-    const asset = skipAssets?.find(
-      (x) => x.denom?.includes("-native") || x.denom?.toLowerCase() === "0x0000000000000000000000000000000000000000"
-    );
-    if (!asset?.decimals) {
-      return {
-        error: `Insufficient balance for gas on ${chain.prettyName}. Need ${gasAmount} gwei but only have ${gasBalance.amount} gwei.`,
-        asset: null,
-        fee: null
-      };
-    }
-    const formattedGasAmount = formatUnits(gasAmount, asset?.decimals);
-    return {
-      error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol} but only have ${gasBalance.formattedAmount} ${asset.symbol}.`,
-      asset: null,
-      fee: null
-    };
-  }
-};
-var validateSvmGasBalance = async ({
-  tx,
-  simulate,
-  feePayerAddress
-}) => {
-  if (!tx) throw new Error("Transaction is required");
-  if (simulate === false) {
-    return {
-      success: true,
-      logs: [],
-      error: null,
-      asset: null,
-      fee: null
-    };
-  }
-  const endpoint = await getRpcEndpointForChain(tx.chainId ?? "");
-  const connection = new Connection(endpoint);
-  if (!connection) throw new Error(`Failed to connect to ${tx.chainId}`);
-  const gasAmount = await getSVMGasAmountForMessage(connection, tx);
-  const skipBalances = await balances({
-    chains: {
-      solana: {
-        address: feePayerAddress ?? tx?.signerAddress,
-        denoms: ["solana-native"]
-      }
-    }
-  });
-  const gasBalance = skipBalances?.chains?.["solana"]?.denoms?.["solana-native"];
-  if (!gasBalance) {
-    return {
-      success: false,
-      error: `Insufficient balance for gas on Solana. Need ${gasAmount / LAMPORTS_PER_SOL} SOL.`,
-      asset: null,
-      fee: null
-    };
-  }
-  if (bignumber_default(gasBalance.amount ?? "").lt(gasAmount)) {
-    return {
-      success: false,
-      error: `Insufficient balance for gas on Solana. Need ${gasAmount / LAMPORTS_PER_SOL} SOL but only have ${gasBalance.formattedAmount} SOL.`,
-      asset: null,
-      fee: null
-    };
-  }
-  return {
-    success: true,
-    error: null,
-    asset: null,
-    fee: null
-  };
-};
-async function getSVMGasAmountForMessage(connection, tx) {
-  const _tx = Buffer.from(tx?.tx ?? "", "base64");
-  const transaction = Transaction.from(_tx);
-  const gas = await connection.getFeeForMessage(
-    transaction.compileMessage(),
-    "confirmed"
-  );
-  if (!gas.value) {
-    throw new Error(
-      `estimateGasForSVMTx error: unable to get gas for transaction on ${tx?.chainId}`
-    );
-  }
-  return gas.value;
-}
-
-// src/private-functions/validateGasBalances.ts
-var validateGasBalances = async ({
-  txs,
-  onValidateGasBalance,
-  getFallbackGasAmount,
-  getCosmosSigner,
-  getEvmSigner,
-  simulate,
-  disabledChainIds,
-  enabledChainIds,
-  getCosmosPriorityFeeDenom,
-  routeId,
-  options,
-  isMultiRoutes
-}) => {
-  const validateResult = await Promise.all(
-    txs.map(async (tx, i) => {
-      if (!tx) {
-        throw new Error(`invalid tx at index ${i}`);
-      }
-      if ("cosmosTx" in tx && !disabledChainIds?.includes(tx?.cosmosTx?.chainId ?? "") && (enabledChainIds === void 0 || enabledChainIds.includes(tx?.cosmosTx?.chainId ?? ""))) {
-        onValidateGasBalance?.({
-          status: "pending"
-        });
-        updateRouteDetails({
-          status: "validating",
-          routeId,
-          options
-        });
-        if (!tx?.cosmosTx?.msgs) {
-          throw new Error(`invalid msgs ${tx?.cosmosTx?.msgs}`);
-        }
-        try {
-          const res = await validateCosmosGasBalance({
-            chainId: tx.cosmosTx.chainId ?? "",
-            signerAddress: tx.cosmosTx.signerAddress ?? "",
-            messages: tx.cosmosTx.msgs,
-            getFallbackGasAmount,
-            getOfflineSigner: getCosmosSigner,
-            txIndex: i,
-            simulate,
-            getCosmosPriorityFeeDenom,
-            isMultiRoutes
-          });
-          return res;
-        } catch (e) {
-          const error = e;
-          return {
-            error: error.message,
-            asset: null,
-            fee: null
-          };
-        }
-      }
-      if ("evmTx" in tx && !disabledChainIds?.includes(tx?.evmTx?.chainId ?? "") && (enabledChainIds === void 0 || enabledChainIds.includes(tx?.evmTx?.chainId ?? ""))) {
-        onValidateGasBalance?.({
-          status: "pending"
-        });
-        updateRouteDetails({
-          status: "validating",
-          routeId,
-          options
-        });
-        const signer = await getEvmSigner?.(tx?.evmTx?.chainId ?? "");
-        if (!signer) {
-          throw new Error(
-            `failed to get signer for chain ${tx?.evmTx?.chainId}`
-          );
-        }
-        try {
-          const res = await validateEvmGasBalance({
-            tx: tx.evmTx,
-            signer,
-            getFallbackGasAmount,
-            useUnlimitedApproval: options?.useUnlimitedApproval,
-            bypassApprovalCheck: options?.bypassApprovalCheck
-          });
-          return res;
-        } catch (e) {
-          const error = e;
-          return {
-            error: error.message,
-            asset: null,
-            fee: null
-          };
-        }
-      }
-      if ("svmTx" in tx && !disabledChainIds?.includes(tx?.svmTx?.chainId ?? "") && (enabledChainIds === void 0 || enabledChainIds.includes(tx?.svmTx?.chainId ?? ""))) {
-        onValidateGasBalance?.({
-          status: "pending"
-        });
-        updateRouteDetails({
-          status: "validating",
-          routeId,
-          options
-        });
-        try {
-          const res = await validateSvmGasBalance({
-            tx: tx.svmTx,
-            simulate,
-            feePayerAddress: options.svmFeePayer?.address
-          });
-          return res;
-        } catch (e) {
-          const error = e;
-          return {
-            error: error.message,
-            asset: null,
-            fee: null
-          };
-        }
-      }
-    })
-  );
-  if (validateResult.filter(Boolean).length === 0) {
-    return;
-  }
-  const txError = validateResult.find((res) => res && res?.error !== null);
-  if (txError) {
-    onValidateGasBalance?.({
-      status: "error"
-    });
-    ClientState.validateGasResults = validateResult;
-    throw new Error(`${txError.error}`);
-  }
-  onValidateGasBalance?.({
-    status: "completed"
-  });
-  ClientState.validateGasResults = validateResult;
-};
-
-// src/private-functions/getChainIdsFromTxs.ts
-var getChainIdsFromTxs = (txs) => {
-  return txs.map((tx) => {
-    if ("cosmosTx" in tx) {
-      return {
-        chainType: "cosmos" /* Cosmos */,
-        chainId: tx.cosmosTx?.chainId
-      };
-    }
-    if ("svmTx" in tx) {
-      return {
-        chainType: "svm" /* Svm */,
-        chainId: tx.svmTx?.chainId
-      };
-    }
-    if ("evmTx" in tx) {
-      return {
-        chainType: "evm" /* Evm */,
-        chainId: tx.evmTx?.chainId
-      };
-    }
-  });
-};
-
-// src/private-functions/executeTransactions.ts
-var executeTransactions = async (options) => {
-  const {
-    txs,
-    onTransactionBroadcast,
-    simulate = true,
-    batchSimulate = true,
-    getFallbackGasAmount = getDefaultFallbackGasAmount,
-    getCosmosSigner,
-    getEvmSigner,
-    onValidateGasBalance,
-    trackTxPollingOptions,
-    batchSignTxs = true,
-    routeId,
-    isMultiRoutes
-  } = options;
-  if (txs === void 0) {
-    throw new Error(
-      "executeTransactions error: txs is undefined in executeTransactions"
-    );
-  }
-  const chainIds = getChainIdsFromTxs(txs);
-  const transactionDetails = txs.map((tx) => {
-    if ("cosmosTx" in tx) {
-      return { chainId: tx.cosmosTx?.chainId, chainType: "cosmos" /* Cosmos */ };
-    } else if ("evmTx" in tx) {
-      return { chainId: tx.evmTx?.chainId, chainType: "evm" /* Evm */ };
-    } else if ("svmTx" in tx) {
-      return { chainId: tx.svmTx?.chainId, chainType: "svm" /* Svm */ };
-    } else {
-      throw new Error("executeRoute error: invalid message type");
-    }
-  });
-  updateRouteDetails({
-    transactionDetails,
-    routeId,
-    options
-  });
-  const isGasStationSourceEVM = chainIds.find((item, i, array) => {
-    return GAS_STATION_CHAIN_IDS.includes(item?.chainId ?? "") && array[i - 1]?.chainType === "evm" /* Evm */;
-  });
-  ClientState.validateGasResults = void 0;
-  const validateChainIds = !batchSimulate ? chainIds.map((x) => x?.chainId ?? "") : isGasStationSourceEVM ? GAS_STATION_CHAIN_IDS : [];
-  await validateGasBalances({
-    txs,
-    getFallbackGasAmount,
-    getCosmosSigner,
-    getEvmSigner,
-    onValidateGasBalance,
-    simulate,
-    disabledChainIds: validateChainIds,
-    getCosmosPriorityFeeDenom: options.getCosmosPriorityFeeDenom,
-    options,
-    routeId,
-    isMultiRoutes
-  });
-  const validateEnabledChainIds = async (chainId) => {
-    await validateGasBalances({
-      txs,
-      getFallbackGasAmount,
-      getCosmosSigner,
-      getEvmSigner,
-      onValidateGasBalance,
-      simulate,
-      enabledChainIds: !batchSimulate ? [chainId] : validateChainIds,
-      getCosmosPriorityFeeDenom: options.getCosmosPriorityFeeDenom,
-      options,
-      routeId,
-      isMultiRoutes
-    });
-  };
-  let signedTxs = [];
-  if (batchSignTxs) {
-    for (let i = 0; i < txs.length; i++) {
-      const tx = txs[i];
-      if (!tx) {
-        throw new Error(`executeRoute error: invalid message at index ${i}`);
-      }
-      if ("cosmosTx" in tx) {
-        await validateEnabledChainIds(tx.cosmosTx?.chainId ?? "");
-        const isAllowedToBatchSignTxsUpfront = await (async () => {
-          try {
-            const currentUserAddress = options.userAddresses.find(
-              (x) => x.chainId === tx.cosmosTx?.chainId
-            )?.address;
-            if (!currentUserAddress) {
-              return false;
-            }
-            const { accountNumber } = await getAccountNumberAndSequence(
-              currentUserAddress,
-              tx.cosmosTx?.chainId
-            );
-            if (accountNumber) {
-              return true;
-            }
-            return false;
-          } catch (_error) {
-            return false;
-          }
-        })();
-        if (!isAllowedToBatchSignTxsUpfront) {
-          continue;
-        }
-        const signedTx = await signCosmosTransaction({
-          tx,
-          options,
-          index: i,
-          routeId
-        });
-        signedTxs.push({
-          index: i,
-          chainId: tx.cosmosTx?.chainId ?? "",
-          tx: signedTx,
-          chainType: "cosmos" /* Cosmos */
-        });
-      }
-      if ("svmTx" in tx) {
-        await validateEnabledChainIds(tx.svmTx?.chainId ?? "");
-        const signedTx = await signSvmTransaction({
-          tx,
-          options,
-          index: i,
-          routeId
-        });
-        if (!signedTx) {
-          throw new Error(`executeRoute error: signedTx is undefined`);
-        }
-        signedTxs.push({
-          index: i,
-          chainId: tx.svmTx?.chainId ?? "",
-          tx: signedTx.toString("base64"),
-          chainType: "svm" /* Svm */
-        });
-      }
-    }
-  }
-  const executeTransaction = async (index) => {
-    const tx = txs[index];
-    if (!tx) {
-      throw new Error(`executeRoute error: invalid message at index ${index}`);
-    }
-    let txResult;
-    const txSigned = signedTxs.find((item) => item.index === index);
-    if (txSigned) {
-      const txResponse = await submitTransaction({
-        chainId: txSigned.chainId,
-        tx: txSigned.tx
-      });
-      txResult = {
-        chainId: txSigned.chainId,
-        txHash: txResponse?.txHash ?? "",
-        explorerLink: txResponse?.explorerLink ?? ""
-      };
-    } else {
-      if ("cosmosTx" in tx) {
-        await validateEnabledChainIds(tx.cosmosTx?.chainId ?? "");
-        txResult = await executeCosmosTransaction({
-          tx,
-          options,
-          index,
-          routeId
-        });
-      } else if ("evmTx" in tx) {
-        await validateEnabledChainIds(tx.evmTx?.chainId ?? "");
-        const txResponse = await executeEvmTransaction(
-          tx,
-          options,
-          index,
-          routeId
-        );
-        txResult = {
-          chainId: tx?.evmTx?.chainId ?? "",
-          txHash: txResponse.transactionHash
-        };
-      } else if ("svmTx" in tx) {
-        await validateEnabledChainIds(tx.svmTx?.chainId ?? "");
-        txResult = await executeSvmTransaction(tx, options, index, routeId);
-      } else {
-        throw new Error("executeRoute error: invalid message type");
-      }
-    }
-    await onTransactionBroadcast?.({ ...txResult });
-    return txResult;
-  };
-  return {
-    transactionDetails,
-    executeTransaction
-  };
-};
-var EVM_GAS_AMOUNT = 15e4;
-var COSMOS_GAS_AMOUNT = {
-  DEFAULT: 3e5,
-  SWAP: 28e5,
-  CARBON: 1e6
-};
-var getDefaultFallbackGasAmount = async (chainId, chainType) => {
-  if (chainType === "evm" /* Evm */) {
-    return EVM_GAS_AMOUNT;
-  }
-  if (chainType !== "cosmos" /* Cosmos */) return void 0;
-  const venuesResult = await venues();
-  const isSwapChain = venuesResult?.some(
-    (venue) => venue.chainId === chainId
-  ) ?? false;
-  const defaultGasAmount = Math.ceil(
-    isSwapChain ? COSMOS_GAS_AMOUNT.SWAP : COSMOS_GAS_AMOUNT.DEFAULT
-  );
-  if (chainId === "carbon-1") {
-    return COSMOS_GAS_AMOUNT.CARBON;
-  }
-  return defaultGasAmount;
-};
-var validateUserAddresses = async (userAddresses) => {
-  const chains3 = await ClientState.getSkipChains();
-  const validations = userAddresses.map((userAddress) => {
-    const chain = chains3.find((chain2) => chain2.chainId === userAddress.chainId);
-    switch (chain?.chainType) {
-      case "cosmos" /* Cosmos */:
-        try {
-          if (chain.chainId?.includes("penumbra")) {
-            try {
-              return chain.bech32Prefix === bech32m.decode(userAddress.address, 143)?.prefix;
-            } catch {
-              return ["penumbracompat1", "tpenumbra"].includes(
-                bech32.decode(userAddress.address, 1023).prefix
-              );
-            }
-          }
-          return chain.bech32Prefix === bech32.decode(userAddress.address, 1023).prefix;
-        } catch {
-          return false;
-        }
-      case "evm" /* Evm */:
-        try {
-          return isAddress(userAddress.address);
-        } catch (_error) {
-          return false;
-        }
-      case "svm" /* Svm */:
-        try {
-          const publicKey = new PublicKey(userAddress.address);
-          return PublicKey.isOnCurve(publicKey);
-        } catch (_error) {
-          return false;
-        }
-      default:
-        return false;
-    }
-  });
-  return validations.every((validation) => validation);
-};
-var createValidAddressList = async ({
-  userAddresses,
-  route: route2
-}) => {
-  let addressList = [];
-  userAddresses.forEach((userAddress, index) => {
-    const requiredChainAddress = route2.requiredChainAddresses[index];
-    if (requiredChainAddress === userAddress?.chainId) {
-      addressList.push(userAddress.address);
-    }
-  });
-  if (addressList.length !== route2.requiredChainAddresses.length) {
-    addressList = userAddresses.map((x) => x.address);
-  }
-  const validLength = addressList.length === route2.requiredChainAddresses.length || addressList.length === route2.chainIds?.length;
-  if (!validLength) {
-    throw new Error("createValidAddressList error: invalid address list");
-  }
-  const isUserAddressesValid = await validateUserAddresses(userAddresses);
-  if (!isUserAddressesValid) {
-    throw new Error("createValidAddressList error: invalid user addresses");
-  }
-  return addressList;
-};
-
-// src/public-functions/executeRoute.ts
-var executeRoute = async (options) => {
-  const { route: route2, userAddresses, appendCosmosMsgs, timeoutSeconds } = options;
-  const { id: routeId } = updateRouteDetails({
-    status: "unconfirmed",
-    options
-  });
-  const addressList = await createValidAddressList({
-    userAddresses,
-    route: route2
-  });
-  const response = await messages({
-    timeoutSeconds,
-    amountIn: route2?.amountIn,
-    amountOut: route2.estimatedAmountOut || "0",
-    sourceAssetChainId: route2?.sourceAssetChainId,
-    sourceAssetDenom: route2?.sourceAssetDenom,
-    destAssetChainId: route2?.destAssetChainId,
-    destAssetDenom: route2?.destAssetDenom,
-    operations: route2?.operations,
-    addressList,
-    slippageTolerancePercent: options.slippageTolerancePercent || "1",
-    chainIdsToAffiliates: ApiState.chainIdsToAffiliates,
-    postRouteHandler: options.postRouteHandler,
-    feePayerAddress: options.svmFeePayer?.address
-  });
-  if (appendCosmosMsgs) {
-    Object.entries(appendCosmosMsgs).forEach(([chainId, msgs]) => {
-      const txIndex = response?.txs?.findIndex(
-        (tx2) => "cosmosTx" in tx2 && tx2.cosmosTx.chainId === chainId
-      );
-      if (txIndex === void 0 || txIndex === -1) return;
-      const tx = response?.txs?.[txIndex];
-      if (tx && "cosmosTx" in tx) {
-        tx.cosmosTx.msgs?.unshift(...msgs);
-      }
-    });
-  }
-  const { transactionDetails, executeTransaction } = await executeTransactions({ ...options, routeId, txs: response?.txs });
-  await executeAndSubscribeToRouteStatus({
-    transactionDetails,
-    executeTransaction,
-    routeId,
-    options
-  });
-};
-
-// src/public-functions/executeMultipleRoutes.ts
-var executeMultipleRoutes = async (options) => {
-  const {
-    route: route2,
-    userAddresses,
-    appendCosmosMsgs,
-    postRouteHandler,
-    slippageTolerancePercent,
-    ...restOptions
-  } = options;
-  const addressList = {};
-  for (const [routeKey, routeValue] of Object.entries(route2)) {
-    const _userAddresses = userAddresses[routeKey];
-    if (_userAddresses === void 0) {
-      throw new Error(
-        `executeMultipleRoutes error: no user addresses found for route: ${routeKey}`
-      );
-    }
-    const routeAddressList = await createValidAddressList({
-      userAddresses: _userAddresses,
-      route: routeValue
-    });
-    addressList[routeKey] = routeAddressList;
-  }
-  const msgsResponses = await Promise.all(
-    Object.entries(route2).map(async ([routeKey, routeValue]) => {
-      const routeAddressList = addressList[routeKey];
-      if (routeAddressList === void 0) {
-        throw new Error(
-          `executeMultipleRoutes error: address list not found for route ${routeKey}`
-        );
-      }
-      return await messages({
-        timeoutSeconds: options.timeoutSeconds,
-        amountIn: routeValue?.amountIn,
-        amountOut: routeValue.estimatedAmountOut || "0",
-        sourceAssetChainId: routeValue?.sourceAssetChainId,
-        sourceAssetDenom: routeValue?.sourceAssetDenom,
-        destAssetChainId: routeValue?.destAssetChainId,
-        destAssetDenom: routeValue?.destAssetDenom,
-        operations: routeValue?.operations,
-        addressList: routeAddressList,
-        slippageTolerancePercent: slippageTolerancePercent?.[routeKey] || "1",
-        chainIdsToAffiliates: ApiState.chainIdsToAffiliates,
-        postRouteHandler: postRouteHandler?.[routeKey],
-        feePayerAddress: options.svmFeePayer?.address
-      });
-    })
-  );
-  let msgsRecord = {};
-  msgsResponses.forEach((msg, index2) => {
-    const routeKey = Object.keys(route2)[index2];
-    if (!routeKey) {
-      throw new Error(
-        `executeMultipleRoutes error: route key not found for index ${index2}`
-      );
-    }
-    const addedCosmosMsgs = appendCosmosMsgs?.[routeKey];
-    if (addedCosmosMsgs) {
-      Object.entries(addedCosmosMsgs).forEach(([chainId, msgs]) => {
-        const txIndex = msg?.txs?.findIndex(
-          (tx2) => "cosmosTx" in tx2 && tx2.cosmosTx.chainId === chainId
-        );
-        if (txIndex === void 0 || txIndex === -1) return;
-        const tx = msg?.txs?.[txIndex];
-        if (tx && "cosmosTx" in tx) {
-          tx.cosmosTx.msgs?.unshift(...msgs);
-        }
-      });
-    }
-    msgsRecord[routeKey] = msg;
-  });
-  let transferIndexToRouteKey = void 0;
-  const cosmosTxIndex0Map = /* @__PURE__ */ new Map();
-  let transferIndex = 0;
-  for (const [routeKey, msgs] of Object.entries(msgsRecord)) {
-    const firstTx = msgs?.txs?.[0];
-    if (firstTx && "cosmosTx" in firstTx) {
-      const { chainId, msgs: firstTxMsgs } = firstTx.cosmosTx;
-      if (!transferIndexToRouteKey) {
-        transferIndexToRouteKey = {};
-      }
-      transferIndexToRouteKey[transferIndex] = routeKey;
-      transferIndex++;
-      if (!cosmosTxIndex0Map.has(chainId)) {
-        cosmosTxIndex0Map.set(chainId, {
-          routeKey,
-          firstCosmosTx: firstTx.cosmosTx
-        });
-      } else {
-        const existing = cosmosTxIndex0Map.get(chainId);
-        if (existing && firstTxMsgs) {
-          const modifyTarget = msgsRecord[existing.routeKey]?.txs?.[0];
-          if (modifyTarget && "cosmosTx" in modifyTarget) {
-            modifyTarget.cosmosTx.msgs?.push(...firstTxMsgs);
-            msgsRecord[routeKey]?.txs?.shift();
-          }
-        }
-      }
-    }
-  }
-  Object.entries(msgsRecord).forEach(([routeKey, msgs]) => {
-    if (msgs?.txs?.length === 0) {
-      delete msgsRecord[routeKey];
-    }
-  });
-  let mainRouteId = void 0;
-  let msgsRecordIndexToRouteId = {};
-  let index = 0;
-  const transactionDetailsList = {};
-  const executeTransactionList = {};
-  const mergedMainAndSecondaryRoutes = Object.entries(msgsRecord).length !== Object.entries(route2).length;
-  for (const [routeKey, msgsResponse] of Object.entries(msgsRecord)) {
-    const { id: routeId } = updateRouteDetails({
-      status: "unconfirmed",
-      options: {
-        route: route2[routeKey],
-        ...restOptions
-      },
-      mainRouteId,
-      transferIndexToRouteKey
-    });
-    msgsRecordIndexToRouteId[index] = routeId;
-    if (routeKey === "mainRoute") {
-      mainRouteId = routeId;
-    }
-    const { transactionDetails, executeTransaction: _executeTransaction } = await executeTransactions({
-      ...restOptions,
-      routeId,
-      txs: msgsResponse?.txs,
-      route: route2[routeKey],
-      userAddresses: userAddresses[routeKey],
-      isMultiRoutes: true
-    });
-    const executeTransaction = async (index2) => {
-      const txResult = await _executeTransaction(index2);
-      if (routeKey !== "mainRoute" || mergedMainAndSecondaryRoutes) {
-        const relatedRoutes = Object.entries(route2).filter(([key]) => key !== "mainRoute").map(([key, route3]) => ({ route: route3, routeKey: key, status: "pending" }));
-        updateRouteDetails({
-          options: {
-            route: route2[routeKey],
-            ...restOptions
-          },
-          routeId: mainRouteId,
-          transferIndexToRouteKey,
-          relatedRoutes
-        });
-      }
-      return txResult;
-    };
-    if (transactionDetails[0]?.chainType === "evm" /* Evm */) {
-      for (const [index2, transactionDetail] of transactionDetails.entries()) {
-        const txResult = await executeTransaction(index2);
-        if (txResult.txHash) {
-          const trackResponse = await trackTransaction({
-            chainId: transactionDetail.chainId,
-            txHash: txResult.txHash,
-            ...options.trackTxPollingOptions
-          });
-          await options?.onTransactionTracked?.({
-            txHash: txResult.txHash,
-            chainId: transactionDetail.chainId,
-            explorerLink: trackResponse.explorerLink
-          });
-          transactionDetail.txHash = txResult.txHash;
-          transactionDetail.explorerLink = trackResponse.explorerLink;
-        }
-      }
-    } else {
-      executeTransactionList[index] = executeTransaction;
-    }
-    transactionDetailsList[index] = transactionDetails;
-    index++;
-  }
-  await Promise.all(
-    Object.entries(msgsRecord).map(([routeKey, msgsResponse], index2) => {
-      return executeAndSubscribeToRouteStatus({
-        transactionDetails: transactionDetailsList[index2],
-        executeTransaction: executeTransactionList[index2],
-        routeId: msgsRecordIndexToRouteId[index2],
-        options: {
-          route: route2[routeKey],
-          userAddresses: userAddresses[routeKey],
-          ...restOptions,
-          onRouteStatusUpdated: (routeStatus) => {
-            const relatedRoutes = Object.entries(route2).filter(([key]) => key !== "mainRoute").map(([key, route3]) => ({ route: route3, routeKey: key, status: routeStatus.status }));
-            if (routeKey !== "mainRoute") {
-              updateRouteDetails({
-                options: {
-                  route: route2[routeKey],
-                  ...restOptions
-                },
-                routeId: mainRouteId,
-                transferIndexToRouteKey,
-                relatedRoutes
-              });
-            }
-            options.onRouteStatusUpdated?.(routeStatus);
-          }
-        }
-      });
-    })
-  );
-};
-
-// src/utils/coingecko.ts
-var getUsdPrice = async (coingeckoId) => {
-  try {
-    const response = await fetch(`https://api.coingecko.com/api/v3/simple/price?ids=${coingeckoId}&vs_currencies=usd`);
-    const data = await response.json();
-    return data?.[coingeckoId]?.usd;
-  } catch (error) {
-    return void 0;
-  }
-};
-
-// src/utils/numbers.ts
-var convertHumanReadableAmountToCryptoAmount = (humanReadableAmount, decimals) => {
-  const cryptoAmount = new bignumber_default(humanReadableAmount).shiftedBy(decimals);
-  return cryptoAmount.toFixed(0);
-};
-var formaTestnet = defineChain({
-  id: 984123,
-  name: "Forma Testnet",
-  nativeCurrency: {
-    name: "TIA",
-    symbol: "TIA",
-    decimals: 18
-  },
-  rpcUrls: {
-    default: {
-      http: ["https://rpc.sketchpad-1.forma.art"]
-    }
-  },
-  blockExplorers: {
-    default: {
-      name: "Forma Explorer",
-      url: "https://explorer.sketchpad-1.forma.art"
-    }
-  },
-  testnet: true
-});
-var evmChains = [
-  arbitrum,
-  avalanche,
-  base,
-  bsc,
-  celo,
-  fantom,
-  filecoin,
-  kava,
-  linea,
-  mainnet,
-  manta,
-  moonbeam,
-  optimism,
-  polygon,
-  polygonMumbai,
-  sepolia,
-  avalancheFuji,
-  baseSepolia,
-  optimismSepolia,
-  arbitrumSepolia,
-  blast,
-  blastSepolia,
-  forma,
-  formaTestnet,
-  sei,
-  bscTestnet,
-  fantomTestnet,
-  kavaTestnet,
-  lineaSepolia,
-  mantaSepoliaTestnet
-];
-
-// src/utils/array.ts
-function isSubset(arrayA, arrayB) {
-  const setA = new Set(arrayA);
-  return arrayB.every((item) => setA.has(item));
-}
-
-// src/public-functions/getRouteWithGasOnReceive.ts
-var GAS_ON_RECEIVE_AMOUNT_USD = {
-  ["cosmos" /* Cosmos */]: 0.1,
-  evm_l2: 2
-};
-var DISABLED_SOURCE_CHAINIDS = ["1", "11155111"];
-var DISABLED_DESTINATION_CHAINIDS = ["solana", "solana-devnet"];
-var getRouteWithGasOnReceive = async (props) => {
-  const originalRoute = props.routeResponse;
-  try {
-    if (DISABLED_SOURCE_CHAINIDS.includes(originalRoute.sourceAssetChainId)) {
-      throw new Error(
-        `Routes from ${originalRoute.sourceAssetChainId} are not supported`
-      );
-    }
-    if (DISABLED_DESTINATION_CHAINIDS.includes(originalRoute.destAssetChainId)) {
-      throw new Error(
-        `Routes to ${originalRoute.destAssetChainId} are not supported`
-      );
-    }
-    const skipChains = ClientState.skipChains ? ClientState.skipChains : await chains({
-      includeEvm: true,
-      includeSvm: true,
-      chainIds: [
-        originalRoute.sourceAssetChainId,
-        originalRoute.destAssetChainId
-      ],
-      onlyTestnets: props.onlyTestnets
-    });
-    const skipAssets = ClientState.skipAssets ? ClientState.skipAssets : await assets({
-      chainIds: [
-        originalRoute.sourceAssetChainId,
-        originalRoute.destAssetChainId
-      ],
-      includeEvmAssets: true,
-      includeSvmAssets: true,
-      onlyTestnets: props.onlyTestnets
-    });
-    const destinationChain = skipChains?.find(
-      (chain) => chain.chainId === originalRoute.destAssetChainId
-    );
-    if (destinationChain?.feeAssets.map((i) => i.denom).includes(originalRoute.destAssetDenom)) {
-      throw new Error(
-        "Destination asset is already a fee asset on the destination chain"
-      );
-    }
-    const gasOnReceiveAmount = await getGasOnReceiveAmount({
-      destinationChain,
-      skipAssets,
-      sourceAsset: skipAssets?.[originalRoute.sourceAssetChainId]?.find(
-        (i) => i.denom === originalRoute.sourceAssetDenom
-      )
-    });
-    if (!gasOnReceiveAmount || gasOnReceiveAmount.length === 0) {
-      throw new Error(
-        "No gas on receive amount found for the destination chain"
-      );
-    }
-    const splitDenoms = chunkArray(gasOnReceiveAmount, 3);
-    let gasRoute;
-    for (const chunk of splitDenoms) {
-      const feeAssetRoutes = chunk.map(
-        async ({ amountOut, denom, amountIn }) => {
-          try {
-            const res = await route({
-              ...props.routeRequest,
-              destAssetDenom: denom,
-              amountIn,
-              amountOut,
-              allowMultiTx: false
-            });
-            return res;
-          } catch (_e) {
-            return null;
-          }
-        }
-      );
-      const result = await Promise.all(feeAssetRoutes);
-      const _gasRoute = result.find((result2) => result2?.usdAmountOut);
-      if (_gasRoute?.usdAmountOut) {
-        gasRoute = _gasRoute;
-        break;
-      }
-    }
-    if (!gasRoute) {
-      throw new Error(
-        "No gas route found for the destination chain with the provided assets"
-      );
-    }
-    const mainRouteAmountIn = bignumber_default(originalRoute?.amountIn ?? 0).minus(bignumber_default(gasRoute.amountIn ?? 0)).toString();
-    const mainRoute = await route({
-      ...props.routeRequest,
-      amountIn: mainRouteAmountIn,
-      amountOut: void 0
-    });
-    if (!mainRoute) {
-      throw new Error("No main route found with the provided assets");
-    }
-    if (originalRoute.txsRequired !== mainRoute.txsRequired || !isSubset(
-      originalRoute?.requiredChainAddresses,
-      mainRoute.requiredChainAddresses
-    )) {
-      throw new Error("Main route does not match the original route");
-    }
-    return {
-      mainRoute,
-      gasRoute
-    };
-  } catch (error) {
-    return {
-      mainRoute: originalRoute,
-      gasRoute: void 0
-    };
-  }
-};
-var getGasOnReceiveAmount = async ({
-  destinationChain,
-  skipAssets,
-  sourceAsset
-}) => {
-  switch (destinationChain?.chainType) {
-    case "cosmos" /* Cosmos */: {
-      const usdPrice = sourceAsset?.coingeckoId ? await getUsdPrice(sourceAsset.coingeckoId) : void 0;
-      return destinationChain.feeAssets.map((asset) => {
-        const destinationAsset = skipAssets?.[destinationChain.chainId]?.find(
-          (i) => i.denom === asset.denom
-        );
-        const gasPrice = asset.gasPrice?.average ?? asset.gasPrice?.high ?? asset.gasPrice?.low;
-        if (!gasPrice || Number(gasPrice) === 0) {
-          if (!usdPrice || !sourceAsset?.decimals) return;
-          const gasOnReceiveAmountUsd = GAS_ON_RECEIVE_AMOUNT_USD["cosmos"];
-          const amountIn = bignumber_default(gasOnReceiveAmountUsd).multipliedBy(usdPrice).toString();
-          return {
-            amountIn: convertHumanReadableAmountToCryptoAmount(
-              amountIn,
-              sourceAsset.decimals
-            ),
-            amountOut: void 0,
-            denom: asset.denom
-          };
-        }
-        return {
-          amountIn: void 0,
-          amountOut: gasPrice && destinationAsset?.decimals ? convertHumanReadableAmountToCryptoAmount(
-            bignumber_default(gasPrice).multipliedBy(3).toNumber(),
-            destinationAsset.decimals
-          ) : void 0,
-          denom: asset.denom
-        };
-      }).filter(Boolean);
-    }
-    case "evm" /* Evm */: {
-      const sourceAssetPrice = sourceAsset?.coingeckoId ? await getUsdPrice(sourceAsset?.coingeckoId) : void 0;
-      const destinationAsset = skipAssets?.[destinationChain.chainId]?.find(
-        (i) => i.denom.includes("-native")
-      );
-      if (!sourceAssetPrice) {
-        const chain = evmChains.find(
-          (chain2) => chain2.id === Number(destinationChain?.chainId)
-        );
-        const client = createPublicClient({
-          chain,
-          transport: fallback([
-            http("https://ethereum.publicnode.com"),
-            http("https://rpc.ankr.com/eth"),
-            http("https://cloudflare-eth.com")
-          ])
-        });
-        const fees = await client.estimateFeesPerGas();
-        return [
-          {
-            amountIn: void 0,
-            amountOut: bignumber_default(15e4).multipliedBy(fees.maxFeePerGas.toString()).multipliedBy(3).toString(),
-            denom: destinationAsset?.denom
-          }
-        ];
-      }
-      const gasPrice = bignumber_default(GAS_ON_RECEIVE_AMOUNT_USD["evm_l2"]).dividedBy(
-        sourceAssetPrice
-      ).toString();
-      return [
-        {
-          amountOut: void 0,
-          amountIn: sourceAsset?.decimals ? convertHumanReadableAmountToCryptoAmount(
-            gasPrice,
-            sourceAsset.decimals
-          ) : void 0,
-          denom: destinationAsset?.denom
-        }
-      ];
-    }
-    default: {
-      return;
-    }
-  }
-};
-var chunkArray = (arr, size = 3) => {
-  const result = [];
-  for (let i = 0; i < arr.length; i += size) {
-    result.push(arr.slice(i, i + size));
-  }
-  return result;
-};
-
-export { AutopilotActionJson, AxelarTransferStateJson, AxelarTransferTypeJson, BridgeTypeJson, CCTPTransferStateJson, ChainTypeJson, ContractCallWithTokenErrorTypeJson, FeeBehaviorJson, FeeTypeJson, GoFastTransferStateJson, HyperlaneTransferStateJson, LayerZeroTransferStateJson, OPInitTransferStateJson, PacketErrorTypeJson, ReasonJson, RoutePriceWarningTypeJson, SendTokenErrorTypeJson, StargateTransferStateJson, StatusErrorTypeJson, TransactionStateJson, TransferStateJson, executeMultipleRoutes, executeRoute, getRouteWithGasOnReceive };