@skip-go/client 1.6.0-alpha.3 → 1.6.0-alpha.5

package/dist/esm/chunk-XIVAEU6S.js

@@ -0,0 +1,1492 @@
+import { updateRouteDetails } from './chunk-3DIX6KRJ.js';
+import { validateCosmosGasBalance } from './chunk-BU5RCZQH.js';
+import { getEncodeObjectFromCosmosMessage } from './chunk-GPEO2I4P.js';
+import { getEVMGasAmountForMessage } from './chunk-GV2QOWB4.js';
+import { getRpcEndpointForChain, accountParser, getSigningStargateClient } from './chunk-DMJMN4J3.js';
+import { chains, findFirstWorkingEndpoint, getIsEthermint, getIsInitia } from './chunk-NUHMTWHP.js';
+import { submitTransaction } from './chunk-ETBJVFQP.js';
+import { venues } from './chunk-A5NZMSTI.js';
+import { ClientState, balances } from './chunk-J24LYWJE.js';
+import { wait, toCamel } from './chunk-F66EKL3W.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 { isAddress, publicActions, maxUint256, formatUnits } from 'viem';
+import { Transaction, PublicKey, Connection, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { BigNumber } from 'bignumber.js';
+import { bech32m, bech32 } from 'bech32';
+
+// 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().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 messages = cosmosMsgs.map((cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg));
+  const txBodyEncodeObject = {
+    typeUrl: "/cosmos.tx.v1beta1.TxBody",
+    value: {
+      messages
+    }
+  };
+  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 messages = cosmosMsgs.map(
+    (cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg)
+  );
+  const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+  const msgs = messages.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 = messages[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 messages = 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 (messages === 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: messages,
+    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,
+  routeId,
+  options
+}) => {
+  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 { onApproveAllowance, useUnlimitedApproval } = options;
+    onApproveAllowance?.({
+      status: "pending",
+      allowance: requiredApproval
+    });
+    updateRouteDetails({
+      status: "allowance",
+      routeId,
+      options
+    });
+    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}`
+      );
+    }
+    onApproveAllowance?.({
+      status: "completed"
+    });
+    updateRouteDetails({
+      status: "signing",
+      routeId,
+      options
+    });
+  }
+};
+
+// src/private-functions/evm/validateEvmGasBalance.ts
+var validateEvmGasBalance = async ({
+  signer,
+  tx,
+  getFallbackGasAmount,
+  options,
+  routeId
+}) => {
+  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;
+  const { bypassApprovalCheck } = options;
+  if (!bypassApprovalCheck && requiredErc20Approvals) {
+    try {
+      await validateEvmTokenApproval({
+        requiredErc20Approvals,
+        signer,
+        chain,
+        gasBalance,
+        tx,
+        routeId,
+        options
+      });
+    } 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
+}) => {
+  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}`);
+  if (!tx.tx) {
+    throw new Error("Transaction is required");
+  }
+  const txBuffer = Buffer.from(tx.tx, "base64");
+  let transaction;
+  try {
+    transaction = 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 / LAMPORTS_PER_SOL;
+}
+
+// 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,
+            routeId,
+            options
+          });
+          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
+          });
+          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
+  });
+  ClientState.validateGasResults = void 0;
+  const validateChainIds = !batchSimulate ? chainIds.map((x) => x?.chainId ?? "") : [];
+  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 chains2 = await 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 === 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
+}) => {
+  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("createValidAddressList error: invalid address list");
+  }
+  const isUserAddressesValid = await validateUserAddresses(userAddresses);
+  if (!isUserAddressesValid) {
+    throw new Error("createValidAddressList error: invalid user addresses");
+  }
+  return addressList;
+};
+
+export { createValidAddressList, executeTransactions };