@skip-go/client 1.3.0 → 1.3.2

package/dist/cjs/chunk-DUJSZRFD.cjs

@@ -0,0 +1,1445 @@
+'use strict';
+
+var chunkHDKNPB2J_cjs = require('./chunk-HDKNPB2J.cjs');
+var chunkTCQMGBFL_cjs = require('./chunk-TCQMGBFL.cjs');
+var chunkN3LR7KTI_cjs = require('./chunk-N3LR7KTI.cjs');
+var chunkF3EB2AQG_cjs = require('./chunk-F3EB2AQG.cjs');
+var chunk4R6OCWRR_cjs = require('./chunk-4R6OCWRR.cjs');
+var chunkKZOSEIWH_cjs = require('./chunk-KZOSEIWH.cjs');
+var chunkMGYSCMET_cjs = require('./chunk-MGYSCMET.cjs');
+var chunkT5LPU5A2_cjs = require('./chunk-T5LPU5A2.cjs');
+var chunkAHRSARNR_cjs = require('./chunk-AHRSARNR.cjs');
+var chunkRFBDXALX_cjs = require('./chunk-RFBDXALX.cjs');
+var chunkEINQFLWN_cjs = require('./chunk-EINQFLWN.cjs');
+var chunkPG7RVHOU_cjs = require('./chunk-PG7RVHOU.cjs');
+var chunkD2W4UBJB_cjs = require('./chunk-D2W4UBJB.cjs');
+var chunk5FR25GF5_cjs = require('./chunk-5FR25GF5.cjs');
+var web3_js = require('@solana/web3.js');
+var bech32 = require('bech32');
+var stargate = require('@cosmjs/stargate');
+var tx_js = require('cosmjs-types/cosmos/tx/v1beta1/tx.js');
+var protoSigning = require('@cosmjs/proto-signing');
+var encoding = require('@cosmjs/encoding');
+var sdkTs = require('@injectivelabs/sdk-ts');
+var utils = require('@injectivelabs/utils');
+var amino = require('@cosmjs/amino');
+var keys_js = require('cosmjs-types/cosmos/crypto/secp256k1/keys.js');
+var any_js = require('cosmjs-types/google/protobuf/any.js');
+var math = require('@cosmjs/math');
+var signing_js = require('cosmjs-types/cosmos/tx/signing/v1beta1/signing.js');
+var viem = require('viem');
+
+// src/private-functions/getRestEndpointForChain.ts
+var getRestEndpointForChain = async (chainId) => {
+  if (chunkD2W4UBJB_cjs.ClientState.endpointOptions.getRestEndpointForChain) {
+    return chunkD2W4UBJB_cjs.ClientState.endpointOptions.getRestEndpointForChain(chainId);
+  }
+  if (chunkD2W4UBJB_cjs.ClientState.endpointOptions.endpoints && chunkD2W4UBJB_cjs.ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = chunkD2W4UBJB_cjs.ClientState.endpointOptions.endpoints[chainId];
+    if (endpointOptions?.rest) {
+      return endpointOptions.rest;
+    }
+  }
+  const chain = chunkT5LPU5A2_cjs.chains().find((chain2) => chain2.chain_id === 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 chunkT5LPU5A2_cjs.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 chunkMGYSCMET_cjs.getRpcEndpointForChain(chainId);
+  const client = chunkD2W4UBJB_cjs.ClientState.signingStargateClientByChainId[chainId] ?? await stargate.StargateClient.connect(endpoint, {
+    accountParser: chunkMGYSCMET_cjs.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 jsonResponse = await chunk5FR25GF5_cjs.createRequestClient({
+    baseUrl: `${endpoint}/cosmos/auth/v1beta1/accounts/${address}`
+  }).get();
+  const response = chunk5FR25GF5_cjs.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
+  };
+};
+function createTransaction({
+  chainId,
+  message,
+  timeoutHeight,
+  memo = "",
+  fee = utils.DEFAULT_STD_FEE,
+  signMode = 1,
+  pubKey,
+  accountNumber,
+  sequence
+}) {
+  const signers = {
+    pubKey,
+    accountNumber,
+    sequence
+  };
+  return sdkTs.createTransactionWithSigners({
+    fee,
+    memo,
+    message,
+    signers,
+    chainId,
+    signMode,
+    timeoutHeight
+  });
+}
+
+// src/private-functions/cosmos/signCosmosMessageDirectEvmos.ts
+var signCosmosMessageDirectEvmos = async (signerAddress, signer, cosmosMsgs, fee, { accountNumber, sequence, chainId }) => {
+  const accounts = await signer.getAccounts();
+  const accountFromSigner = accounts.find((account) => account.address === signerAddress);
+  if (!accountFromSigner) {
+    throw new Error("signCosmosMessageDirectEvmos: failed to retrieve account from signer");
+  }
+  const messages2 = cosmosMsgs.map(
+    (cosmosMsg) => chunkN3LR7KTI_cjs.getEncodeObjectFromCosmosMessageInjective(cosmosMsg)
+  );
+  const pk = Buffer.from(accountFromSigner.pubkey).toString("base64");
+  const { signDoc } = createTransaction({
+    pubKey: pk,
+    chainId,
+    message: messages2,
+    sequence,
+    accountNumber,
+    timeoutHeight: 0,
+    fee
+  });
+  const directSignResponse = await signer.signDirect(signerAddress, signDoc);
+  return tx_js.TxRaw.fromPartial({
+    bodyBytes: directSignResponse.signed.bodyBytes,
+    authInfoBytes: directSignResponse.signed.authInfoBytes,
+    signatures: [encoding.fromBase64(directSignResponse.signature.signature)]
+  });
+};
+var signCosmosMessageDirectInjective = async (signerAddress, signer, cosmosMsgs, fee, { accountNumber, sequence, chainId }) => {
+  const accounts = await signer.getAccounts();
+  const accountFromSigner = accounts.find((account) => account.address === signerAddress);
+  if (!accountFromSigner) {
+    throw new Error("signCosmosMessageDirectInjective: failed to retrieve account from signer");
+  }
+  const restEndpoint = await getRestEndpointForChain(chainId);
+  const chainRestTendermintApi = new sdkTs.ChainRestTendermintApi(restEndpoint);
+  const latestBlock = await chainRestTendermintApi.fetchLatestBlock();
+  const latestHeight = latestBlock.header.height;
+  const timeoutHeight = new utils.BigNumberInBase(latestHeight).plus(utils.DEFAULT_BLOCK_TIMEOUT_HEIGHT);
+  const pk = Buffer.from(accountFromSigner.pubkey).toString("base64");
+  const messages2 = cosmosMsgs.map(
+    (cosmosMsg) => chunkN3LR7KTI_cjs.getEncodeObjectFromCosmosMessageInjective(cosmosMsg)
+  );
+  const { signDoc } = createTransaction({
+    pubKey: pk,
+    chainId,
+    message: messages2,
+    sequence,
+    accountNumber,
+    timeoutHeight: timeoutHeight.toNumber(),
+    fee
+  });
+  const directSignResponse = await signer.signDirect(
+    signerAddress,
+    // @ts-expect-error TODO: Fix this
+    signDoc
+  );
+  return tx_js.TxRaw.fromPartial({
+    bodyBytes: directSignResponse.signed.bodyBytes,
+    authInfoBytes: directSignResponse.signed.authInfoBytes,
+    signatures: [encoding.fromBase64(directSignResponse.signature.signature)]
+  });
+};
+var pubkeyType = {
+  ethsecp256k1: "ethermint/PubKeyEthSecp256k1",
+  ...amino.pubkeyType
+};
+
+// 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: encoding.toBase64(pubkey)
+  };
+}
+
+// src/proto-signing/pubkey.ts
+function makePubkeyAnyFromAccount(account, chainId) {
+  const isEthermint = chunkT5LPU5A2_cjs.getIsEthermint(chainId);
+  const pubkey = isEthermint ? encodeEthSecp256k1Pubkey(account.pubkey) : amino.encodeSecp256k1Pubkey(account.pubkey);
+  const pubkeyAny = encodePubkeyToAny(pubkey, chainId, isEthermint);
+  return pubkeyAny;
+}
+function encodePubkeyToAny(pubkey, chainId, isEthermint) {
+  if (isEthermint) {
+    const pubkeyProto = keys_js.PubKey.fromPartial({
+      key: encoding.fromBase64(pubkey.value)
+    });
+    let typeUrl = "";
+    if (chainId?.includes("injective")) {
+      typeUrl = "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
+    } else {
+      typeUrl = "/ethermint.crypto.v1.ethsecp256k1.PubKey";
+    }
+    return any_js.Any.fromPartial({
+      typeUrl,
+      value: Uint8Array.from(keys_js.PubKey.encode(pubkeyProto).finish())
+    });
+  } else {
+    const isInitia = chunkT5LPU5A2_cjs.getIsInitia(chainId);
+    const pubkeyProto = keys_js.PubKey.fromPartial({
+      key: encoding.fromBase64(pubkey.value)
+    });
+    if (isInitia) {
+      return any_js.Any.fromPartial({
+        typeUrl: "/initia.crypto.v1beta1.ethsecp256k1.PubKey",
+        value: Uint8Array.from(keys_js.PubKey.encode(pubkeyProto).finish())
+      });
+    }
+    return protoSigning.encodePubkey(pubkey);
+  }
+}
+var signCosmosMessageDirect = async (options) => {
+  const {
+    signer,
+    signerAddress,
+    chainId,
+    cosmosMsgs,
+    fee,
+    signerData: { accountNumber, sequence, chainId: signerChainId }
+  } = options;
+  if (chainId.includes("evmos")) {
+    return signCosmosMessageDirectEvmos(signerAddress, signer, cosmosMsgs, fee, {
+      accountNumber,
+      sequence,
+      chainId: signerChainId
+    });
+  }
+  if (chainId.includes("injective")) {
+    return signCosmosMessageDirectInjective(signerAddress, signer, cosmosMsgs, fee, {
+      accountNumber,
+      sequence,
+      chainId: signerChainId
+    });
+  }
+  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) => chunkN3LR7KTI_cjs.getEncodeObjectFromCosmosMessage(cosmosMsg));
+  const txBodyEncodeObject = {
+    typeUrl: "/cosmos.tx.v1beta1.TxBody",
+    value: {
+      messages: messages2
+    }
+  };
+  const txBodyBytes = chunkD2W4UBJB_cjs.ClientState.registry.encode(txBodyEncodeObject);
+  const gasLimit = math.Int53.fromString(fee.gas).toNumber();
+  const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainId);
+  const authInfoBytes = protoSigning.makeAuthInfoBytes(
+    [{ pubkey: pubkeyAny, sequence }],
+    fee.amount,
+    gasLimit,
+    fee.granter,
+    fee.payer
+  );
+  const signDoc = protoSigning.makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber);
+  const { signature, signed } = await signer.signDirect(signerAddress, signDoc);
+  return tx_js.TxRaw.fromPartial({
+    bodyBytes: signed.bodyBytes,
+    authInfoBytes: signed.authInfoBytes,
+    signatures: [encoding.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) => chunkN3LR7KTI_cjs.getEncodeObjectFromCosmosMessage(cosmosMsg));
+  const signMode = signing_js.SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+  const msgs = messages2.map((msg) => chunkD2W4UBJB_cjs.ClientState.aminoTypes.toAmino(msg));
+  console.log("sign cosmos message amino", msgs, fee, signerChainId, "", accountNumber, sequence);
+  const signDoc = amino.makeSignDoc(msgs, fee, signerChainId, "", accountNumber, sequence);
+  const { signature, signed } = await signer.signAmino(signerAddress, signDoc);
+  const signedTxBody = {
+    messages: signed.msgs.map((msg) => chunkD2W4UBJB_cjs.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 = chunkD2W4UBJB_cjs.ClientState.registry.encode(signedTxBodyEncodeObject);
+  const signedGasLimit = math.Int53.fromString(signed.fee.gas).toNumber();
+  const signedSequence = math.Int53.fromString(signed.sequence).toNumber();
+  const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainId);
+  const signedAuthInfoBytes = protoSigning.makeAuthInfoBytes(
+    [{ pubkey: pubkeyAny, sequence: signedSequence }],
+    signed.fee.amount,
+    signedGasLimit,
+    signed.fee.granter,
+    signed.fee.payer,
+    signMode
+  );
+  return tx_js.TxRaw.fromPartial({
+    bodyBytes: signedTxBodyBytes,
+    authInfoBytes: signedAuthInfoBytes,
+    signatures: [encoding.fromBase64(signature.signature)]
+  });
+};
+var signCosmosTransaction = async ({
+  tx,
+  options,
+  index
+}) => {
+  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 = chunkD2W4UBJB_cjs.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 chunkMGYSCMET_cjs.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
+  });
+  if (protoSigning.isOfflineDirectSigner(signer)) {
+    rawTx = await signCosmosMessageDirect({
+      ...commonRawTxBody,
+      signer
+    });
+  } else {
+    rawTx = await signCosmosMessageAmino({ ...commonRawTxBody, signer });
+  }
+  options?.onTransactionSigned?.({
+    chainId
+  });
+  const txBytes = tx_js.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
+}) => {
+  if (tx === void 0) {
+    throw new Error("executeCosmosTransaction error: tx is undefined");
+  }
+  const rawTxBase64 = await signCosmosTransaction({
+    tx,
+    options,
+    index
+  });
+  const chainId = tx.cosmosTx?.chainId;
+  const txResponse = await chunkRFBDXALX_cjs.submit({
+    chainId,
+    tx: rawTxBase64
+  });
+  return {
+    chainId: tx?.cosmosTx?.chainId ?? "",
+    txHash: txResponse?.txHash ?? ""
+  };
+};
+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) => {
+  const gasArray = chunkD2W4UBJB_cjs.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(viem.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
+      });
+      const txHash2 = await extendedSigner.writeContract({
+        account: evmSigner.account,
+        address: requiredApproval.tokenContract,
+        abi: erc20ABI,
+        functionName: "approve",
+        args: [
+          requiredApproval.spender,
+          useUnlimitedApproval ? viem.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
+  });
+  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)
+  });
+  onTransactionSigned?.({
+    chainId: evmTx.chainId
+  });
+  const receipt = await extendedSigner.waitForTransactionReceipt({
+    hash: txHash
+  });
+  return receipt;
+};
+var signSvmTransaction = async ({
+  tx,
+  options,
+  index
+}) => {
+  const gasArray = chunkD2W4UBJB_cjs.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 = web3_js.Transaction.from(txBuffer);
+  if (!("signTransaction" in signer)) return;
+  options?.onTransactionSignRequested?.({
+    chainId: svmTx.chainId,
+    signerAddress: signer.publicKey?.toBase58(),
+    txIndex: index
+  });
+  const signedTx = await signer.signTransaction(transaction);
+  options?.onTransactionSigned?.({ chainId: svmTx.chainId });
+  const serializedTx = signedTx.serialize();
+  return serializedTx;
+};
+
+// src/private-functions/svm/executeSvmTransaction.ts
+var executeSvmTransaction = async (tx, options) => {
+  const svmTx = tx?.svmTx;
+  if (!svmTx?.chainId) {
+    throw new Error("executeSvmTransaction error: chainId not found in svmTx");
+  }
+  const signedTx = await signSvmTransaction({ tx, options });
+  if (!signedTx) {
+    throw new Error("executeSvmTransaction error: signedTx is undefined");
+  }
+  const endpoint = await chunkMGYSCMET_cjs.getRpcEndpointForChain(svmTx.chainId);
+  const connection = new web3_js.Connection(endpoint);
+  let signature;
+  await chunkEINQFLWN_cjs.submitTransaction({
+    chainId: svmTx.chainId,
+    tx: signedTx.toString("base64")
+  }).then((res) => {
+    signature = res?.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
+        };
+      }
+      if (getStatusCount > 12) {
+        await chunk5FR25GF5_cjs.wait(3e3);
+        throw new Error(
+          `executeSvmTransaction error: waiting finalized status timed out for ${signature}`
+        );
+      }
+      getStatusCount++;
+      await chunk5FR25GF5_cjs.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(viem.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 chunkD2W4UBJB_cjs.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 = viem.formatUnits(allowanceGasFee, asset?.decimals);
+      throw new Error(
+        `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol}.`
+      );
+    }
+    if (chunk4R6OCWRR_cjs.BigNumber(gasBalance.amount).lt(Number(allowanceGasFee))) {
+      const chainAssets = (await chunkD2W4UBJB_cjs.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 = viem.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 ? viem.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
+}) => {
+  const chainId = tx?.chainId ?? "";
+  const skipAssets = (await chunkD2W4UBJB_cjs.ClientState.getSkipAssets({ chainId }))?.[chainId];
+  const skipChains = await chunkD2W4UBJB_cjs.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 chunkD2W4UBJB_cjs.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 (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 chunkF3EB2AQG_cjs.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 = viem.formatUnits(gasAmount, asset?.decimals);
+    return {
+      error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol}.`,
+      asset: null,
+      fee: null
+    };
+  }
+  if (chunk4R6OCWRR_cjs.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 = viem.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
+}) => {
+  if (!tx) throw new Error("Transaction is required");
+  const endpoint = await chunkMGYSCMET_cjs.getRpcEndpointForChain(tx.chainId ?? "");
+  const connection = new web3_js.Connection(endpoint);
+  if (!connection) throw new Error(`Failed to connect to ${tx.chainId}`);
+  if (!tx.tx) {
+    throw new Error("Transaction is required");
+  }
+  const txBuffer = Buffer.from(tx.tx, "base64");
+  let transaction;
+  try {
+    transaction = web3_js.Transaction.from(txBuffer);
+  } catch (decodeError) {
+    return {
+      success: false,
+      error: { decodeError: decodeError.message },
+      asset: null,
+      fee: null
+    };
+  }
+  const simulation = await connection.simulateTransaction(transaction);
+  if (simulation.value.err) {
+    const logs = simulation.value.logs ?? [];
+    const shortfall = getSolShortfall(logs);
+    const insufficientLamports = logs.some((log) => log.includes("insufficient lamports")) && shortfall !== null;
+    const insufficientFundsForRent = Object.keys(simulation.value.err).includes(
+      "InsufficientFundsForRent"
+    );
+    const errMsg = insufficientLamports ? `Insufficient balance for gas on Solana. You need ${shortfall.toFixed(6)} SOL to proceed.` : insufficientFundsForRent ? "Insufficient funds for rent on Solana. You need to fund your account." : "Simulation failed";
+    return {
+      success: false,
+      logs,
+      error: errMsg,
+      asset: null,
+      fee: null
+    };
+  }
+  return {
+    success: true,
+    logs: simulation.value.logs ?? [],
+    error: null,
+    asset: null,
+    fee: null
+  };
+};
+function getSolShortfall(logs) {
+  const line = logs.find((l) => l.includes("insufficient lamports"));
+  if (!line) return null;
+  const m = line.match(/insufficient lamports (\d+), need (\d+)/);
+  if (!m) return null;
+  const have = parseInt(m[1] ?? "0", 10);
+  const need = parseInt(m[2] ?? "0", 10);
+  const shortfallLamports = need - have;
+  return shortfallLamports / web3_js.LAMPORTS_PER_SOL;
+}
+
+// src/private-functions/validateGasBalances.ts
+var validateGasBalances = async ({
+  txs,
+  onValidateGasBalance,
+  getFallbackGasAmount,
+  getCosmosSigner,
+  getEvmSigner,
+  simulate,
+  disabledChainIds,
+  enabledChainIds,
+  useUnlimitedApproval,
+  getCosmosPriorityFeeDenom
+}) => {
+  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"
+        });
+        if (!tx?.cosmosTx?.msgs) {
+          throw new Error(`invalid msgs ${tx?.cosmosTx?.msgs}`);
+        }
+        try {
+          const res = await chunkHDKNPB2J_cjs.validateCosmosGasBalance({
+            chainId: tx.cosmosTx.chainId ?? "",
+            signerAddress: tx.cosmosTx.signerAddress ?? "",
+            messages: tx.cosmosTx.msgs,
+            getFallbackGasAmount,
+            getOfflineSigner: getCosmosSigner,
+            txIndex: i,
+            simulate,
+            getCosmosPriorityFeeDenom
+          });
+          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"
+        });
+        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
+          });
+          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"
+        });
+        try {
+          const res = await validateSvmGasBalance({
+            tx: tx.svmTx
+          });
+          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"
+    });
+    chunkD2W4UBJB_cjs.ClientState.validateGasResults = validateResult;
+    throw new Error(`${txError.error}`);
+  }
+  onValidateGasBalance?.({
+    status: "completed"
+  });
+  chunkD2W4UBJB_cjs.ClientState.validateGasResults = validateResult;
+};
+
+// src/private-functions/executeTransactions.ts
+var executeTransactions = async (options) => {
+  const {
+    txs,
+    onTransactionBroadcast,
+    onTransactionCompleted,
+    simulate = true,
+    batchSimulate = true,
+    getFallbackGasAmount = getDefaultFallbackGasAmount,
+    getCosmosSigner,
+    getEvmSigner,
+    onValidateGasBalance,
+    trackTxPollingOptions,
+    batchSignTxs = true
+  } = options;
+  if (txs === void 0) {
+    throw new Error(
+      "executeTransactions error: txs is undefined in executeTransactions"
+    );
+  }
+  const chainIds = txs.map((tx) => {
+    if ("cosmosTx" in tx) {
+      return {
+        chainType: "cosmos",
+        chainId: tx.cosmosTx?.chainId
+      };
+    }
+    if ("svmTx" in tx) {
+      return {
+        chainType: "svm",
+        chainId: tx.svmTx?.chainId
+      };
+    }
+    if ("evmTx" in tx) {
+      return {
+        chainType: "evm",
+        chainId: tx.evmTx?.chainId
+      };
+    }
+  });
+  const isGasStationSourceEVM = chainIds.find((item, i, array) => {
+    return chunkKZOSEIWH_cjs.GAS_STATION_CHAIN_IDS.includes(item?.chainId ?? "") && array[i - 1]?.chainType === "evm";
+  });
+  chunkD2W4UBJB_cjs.ClientState.validateGasResults = void 0;
+  const validateChainIds = !batchSimulate ? chainIds.map((x) => x?.chainId ?? "") : isGasStationSourceEVM ? chunkKZOSEIWH_cjs.GAS_STATION_CHAIN_IDS : [];
+  await validateGasBalances({
+    txs,
+    getFallbackGasAmount,
+    getCosmosSigner,
+    getEvmSigner,
+    onValidateGasBalance,
+    simulate,
+    disabledChainIds: validateChainIds,
+    getCosmosPriorityFeeDenom: options.getCosmosPriorityFeeDenom
+  });
+  const validateEnabledChainIds = async (chainId) => {
+    await validateGasBalances({
+      txs,
+      getFallbackGasAmount,
+      getCosmosSigner,
+      getEvmSigner,
+      onValidateGasBalance,
+      simulate,
+      enabledChainIds: !batchSimulate ? [chainId] : validateChainIds,
+      getCosmosPriorityFeeDenom: options.getCosmosPriorityFeeDenom
+    });
+  };
+  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 signedTx = await signCosmosTransaction({
+          tx,
+          options,
+          index: i
+        });
+        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 });
+        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 */
+        });
+      }
+    }
+  }
+  for (let i = 0; i < txs.length; i++) {
+    const tx = txs[i];
+    if (!tx) {
+      throw new Error(`executeRoute error: invalid message at index ${i}`);
+    }
+    let txResult;
+    const txSigned = signedTxs.find((item) => item.index === i);
+    if (txSigned) {
+      const txResponse = await chunkRFBDXALX_cjs.submit({
+        chainId: txSigned.chainId,
+        tx: txSigned.tx
+      });
+      txResult = {
+        chainId: txSigned.chainId,
+        txHash: txResponse?.txHash ?? ""
+      };
+    } else {
+      if ("cosmosTx" in tx) {
+        await validateEnabledChainIds(tx.cosmosTx?.chainId ?? "");
+        txResult = await executeCosmosTransaction({
+          tx,
+          options,
+          index: i
+        });
+      } else if ("evmTx" in tx) {
+        await validateEnabledChainIds(tx.evmTx?.chainId ?? "");
+        const txResponse = await executeEvmTransaction(tx, options, i);
+        txResult = {
+          chainId: tx?.evmTx?.chainId ?? "",
+          txHash: txResponse.transactionHash
+        };
+      } else if ("svmTx" in tx) {
+        await validateEnabledChainIds(tx.svmTx?.chainId ?? "");
+        txResult = await executeSvmTransaction(tx, options);
+      } else {
+        throw new Error("executeRoute error: invalid message type");
+      }
+    }
+    await onTransactionBroadcast?.({ ...txResult });
+    const txStatusResponse = await chunkTCQMGBFL_cjs.waitForTransaction({
+      ...txResult,
+      ...trackTxPollingOptions,
+      onTransactionTracked: options.onTransactionTracked
+    });
+    await onTransactionCompleted?.({
+      chainId: txResult.chainId,
+      txHash: txResult.txHash,
+      status: txStatusResponse
+    });
+  }
+};
+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 chunkPG7RVHOU_cjs.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 executeRoute = async (options) => {
+  const { route, userAddresses, beforeMsg, afterMsg, timeoutSeconds } = options;
+  let addressList = [];
+  userAddresses.forEach((userAddress, index) => {
+    const requiredChainAddress = route.requiredChainAddresses[index];
+    if (requiredChainAddress === userAddress?.chainId) {
+      addressList.push(userAddress.address);
+    }
+  });
+  if (addressList.length !== route.requiredChainAddresses.length) {
+    addressList = userAddresses.map((x) => x.address);
+  }
+  const validLength = addressList.length === route.requiredChainAddresses.length || addressList.length === route.chainIds?.length;
+  if (!validLength) {
+    throw new Error("executeRoute error: invalid address list");
+  }
+  const isUserAddressesValid = await validateUserAddresses(userAddresses);
+  if (!isUserAddressesValid) {
+    throw new Error("executeRoute error: invalid user addresses");
+  }
+  const response = await chunkAHRSARNR_cjs.messages({
+    timeoutSeconds,
+    amountIn: route?.amountIn,
+    amountOut: route.estimatedAmountOut || "0",
+    sourceAssetChainId: route?.sourceAssetChainId,
+    sourceAssetDenom: route?.sourceAssetDenom,
+    destAssetChainId: route?.destAssetChainId,
+    destAssetDenom: route?.destAssetDenom,
+    operations: route?.operations,
+    addressList,
+    slippageTolerancePercent: options.slippageTolerancePercent || "1",
+    chainIdsToAffiliates: chunk5FR25GF5_cjs.ApiState.chainIdsToAffiliates,
+    postRouteHandler: options.postRouteHandler
+  });
+  if (beforeMsg && (response?.txs?.length ?? 0) > 0) {
+    const firstTx = response?.txs?.[0];
+    if (firstTx && "cosmosTx" in firstTx) {
+      firstTx.cosmosTx?.msgs?.unshift(beforeMsg);
+    }
+  }
+  if (afterMsg && (response?.txs?.length ?? 0) > 0) {
+    const lastTx = response?.txs?.[response.txs.length - 1];
+    if (lastTx && "cosmosTx" in lastTx) {
+      lastTx.cosmosTx?.msgs?.push(afterMsg);
+    }
+  }
+  await executeTransactions({ ...options, txs: response?.txs });
+};
+var validateUserAddresses = async (userAddresses) => {
+  const chains2 = await chunkD2W4UBJB_cjs.ClientState.getSkipChains();
+  const validations = userAddresses.map((userAddress) => {
+    const chain = chains2.find((chain2) => chain2.chainId === userAddress.chainId);
+    switch (chain?.chainType) {
+      case "cosmos" /* Cosmos */:
+        try {
+          if (chain.chainId?.includes("penumbra")) {
+            try {
+              return chain.bech32Prefix === bech32.bech32m.decode(userAddress.address, 143)?.prefix;
+            } catch {
+              return ["penumbracompat1", "tpenumbra"].includes(
+                bech32.bech32.decode(userAddress.address, 1023).prefix
+              );
+            }
+          }
+          return chain.bech32Prefix === bech32.bech32.decode(userAddress.address, 1023).prefix;
+        } catch {
+          return false;
+        }
+      case "evm" /* Evm */:
+        try {
+          return viem.isAddress(userAddress.address);
+        } catch (_error) {
+          return false;
+        }
+      case "svm" /* Svm */:
+        try {
+          const publicKey = new web3_js.PublicKey(userAddress.address);
+          return web3_js.PublicKey.isOnCurve(publicKey);
+        } catch (_error) {
+          return false;
+        }
+      default:
+        return false;
+    }
+  });
+  return validations.every((validation) => validation);
+};
+
+exports.executeRoute = executeRoute;