@skip-go/client 1.0.1 → 1.0.3-alpha-0

package/dist/chunk-F75DC5RW.js

@@ -0,0 +1,1786 @@
+import { BigNumber } from './chunk-VQ5SIQWU.js';
+import { GAS_STATION_CHAIN_IDS } from './chunk-SWYON2RG.js';
+import { getSigningStargateClient, getRpcEndpointForChain, accountParser } from './chunk-SONZJVQM.js';
+import { chains, findFirstWorkingEndpoint, getIsEthermint, getIsInitia } from './chunk-JTIHU43D.js';
+import { MsgDepositForBurn, MsgDepositForBurnWithCaller, MsgExecute, MsgInitiateTokenDeposit, BaseVestingAccount, Timestamp, toTimestamp, Period, fromTimestamp, isSet, fromJsonTimestamp } from './chunk-TD63P2AG.js';
+import { messages } from './chunk-DW4U6YI6.js';
+import { submitTransaction } from './chunk-RDRDFJQE.js';
+import { trackTransaction } from './chunk-MGVXJ2U4.js';
+import { transactionStatus } from './chunk-33K6EESX.js';
+import { ClientState, balances } from './chunk-BRMONS6A.js';
+import { ApiState, wait, createRequestClient, toCamel } from './chunk-W6TBGBV3.js';
+import { PublicKey, Transaction, Connection, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { bech32m, bech32 } from 'bech32';
+import { StargateClient, GasPrice, calculateFee } from '@cosmjs/stargate';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx.js';
+import { isOfflineDirectSigner, makeAuthInfoBytes, makeSignDoc, encodePubkey } from '@cosmjs/proto-signing';
+import { fromBase64, toUtf8, toBase64 } from '@cosmjs/encoding';
+import { ChainRestTendermintApi, MsgTransfer as MsgTransfer$1, MsgExecuteContractCompat, createTransactionWithSigners } from '@injectivelabs/sdk-ts';
+import { MsgSend } from 'cosmjs-types/cosmos/bank/v1beta1/tx.js';
+import { MsgExecuteContract } from 'cosmjs-types/cosmwasm/wasm/v1/tx.js';
+import { MsgTransfer } from 'cosmjs-types/ibc/applications/transfer/v1/tx.js';
+import _m0 from 'protobufjs/minimal.js';
+import { BigNumberInBase, DEFAULT_BLOCK_TIMEOUT_HEIGHT, DEFAULT_STD_FEE } from '@injectivelabs/utils';
+import { pubkeyType as pubkeyType$1, makeSignDoc as makeSignDoc$1, encodeSecp256k1Pubkey } from '@cosmjs/amino';
+import { PubKey } from 'cosmjs-types/cosmos/crypto/secp256k1/keys.js';
+import { Any } from 'cosmjs-types/google/protobuf/any.js';
+import { Int53, Decimal } from '@cosmjs/math';
+import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing.js';
+import { isAddress, publicActions, maxUint256, formatUnits } from 'viem';
+
+// 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.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(
+      `getRpcEndpointForChain error: failed to find RPC endpoint for chain '${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 '${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 jsonResponse = await createRequestClient({
+    baseUrl: `${endpoint}/cosmos/auth/v1beta1/accounts/${address}`
+  }).get();
+  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
+  };
+};
+function createBaseClawbackVestingAccount() {
+  return {
+    baseVestingAccount: void 0,
+    funderAddress: "",
+    startTime: /* @__PURE__ */ new Date(),
+    lockupPeriods: [],
+    vestingPeriods: []
+  };
+}
+var ClawbackVestingAccount = {
+  typeUrl: "/evmos.vesting.v2.ClawbackVestingAccount",
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.baseVestingAccount !== void 0) {
+      BaseVestingAccount.encode(message.baseVestingAccount, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.funderAddress !== "") {
+      writer.uint32(18).string(message.funderAddress);
+    }
+    if (message.startTime !== void 0) {
+      Timestamp.encode(toTimestamp(message.startTime), writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.lockupPeriods) {
+      Period.encode(v, writer.uint32(34).fork()).ldelim();
+    }
+    for (const v of message.vestingPeriods) {
+      Period.encode(v, writer.uint32(42).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseClawbackVestingAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseVestingAccount = BaseVestingAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.funderAddress = reader.string();
+          break;
+        case 3:
+          message.startTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.lockupPeriods.push(Period.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.vestingPeriods.push(Period.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      baseVestingAccount: isSet(object.baseVestingAccount) ? BaseVestingAccount.fromJSON(object.baseVestingAccount) : void 0,
+      funderAddress: isSet(object.funderAddress) ? String(object.funderAddress) : "",
+      startTime: isSet(object.startTime) ? fromJsonTimestamp(object.startTime) : void 0,
+      lockupPeriods: Array.isArray(object?.lockupPeriods) ? object.lockupPeriods.map((e) => Period.fromJSON(e)) : [],
+      vestingPeriods: Array.isArray(object?.vestingPeriods) ? object.vestingPeriods.map((e) => Period.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    message.baseVestingAccount !== void 0 && (obj.baseVestingAccount = message.baseVestingAccount ? BaseVestingAccount.toJSON(message.baseVestingAccount) : void 0);
+    message.funderAddress !== void 0 && (obj.funderAddress = message.funderAddress);
+    message.startTime !== void 0 && (obj.startTime = message.startTime.toISOString());
+    if (message.lockupPeriods) {
+      obj.lockupPeriods = message.lockupPeriods.map((e) => e ? Period.toJSON(e) : void 0);
+    } else {
+      obj.lockupPeriods = [];
+    }
+    if (message.vestingPeriods) {
+      obj.vestingPeriods = message.vestingPeriods.map((e) => e ? Period.toJSON(e) : void 0);
+    } else {
+      obj.vestingPeriods = [];
+    }
+    return obj;
+  },
+  fromPartial(object) {
+    const message = createBaseClawbackVestingAccount();
+    message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? BaseVestingAccount.fromPartial(object.baseVestingAccount) : void 0;
+    message.funderAddress = object.funderAddress ?? "";
+    message.startTime = object.startTime ?? void 0;
+    message.lockupPeriods = object.lockupPeriods?.map((e) => Period.fromPartial(e)) || [];
+    message.vestingPeriods = object.vestingPeriods?.map((e) => Period.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object) {
+    const message = createBaseClawbackVestingAccount();
+    if (object.base_vesting_account !== void 0 && object.base_vesting_account !== null) {
+      message.baseVestingAccount = BaseVestingAccount.fromAmino(object.base_vesting_account);
+    }
+    if (object.funder_address !== void 0 && object.funder_address !== null) {
+      message.funderAddress = object.funder_address;
+    }
+    if (object.start_time !== void 0 && object.start_time !== null) {
+      message.startTime = fromTimestamp(Timestamp.fromAmino(object.start_time));
+    }
+    message.lockupPeriods = object.lockup_periods?.map((e) => Period.fromAmino(e)) || [];
+    message.vestingPeriods = object.vesting_periods?.map((e) => Period.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.base_vesting_account = message.baseVestingAccount ? BaseVestingAccount.toAmino(message.baseVestingAccount) : void 0;
+    obj.funder_address = message.funderAddress === "" ? void 0 : message.funderAddress;
+    obj.start_time = message.startTime ? Timestamp.toAmino(toTimestamp(message.startTime)) : void 0;
+    if (message.lockupPeriods) {
+      obj.lockup_periods = message.lockupPeriods.map((e) => e ? Period.toAmino(e) : void 0);
+    } else {
+      obj.lockup_periods = message.lockupPeriods;
+    }
+    if (message.vestingPeriods) {
+      obj.vesting_periods = message.vestingPeriods.map((e) => e ? Period.toAmino(e) : void 0);
+    } else {
+      obj.vesting_periods = message.vestingPeriods;
+    }
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return ClawbackVestingAccount.fromAmino(object.value);
+  },
+  toAminoMsg(message) {
+    return {
+      type: "vesting/ClawbackVestingAccount",
+      value: ClawbackVestingAccount.toAmino(message)
+    };
+  },
+  fromProtoMsg(message) {
+    return ClawbackVestingAccount.decode(message.value);
+  },
+  toProto(message) {
+    return ClawbackVestingAccount.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/evmos.vesting.v2.ClawbackVestingAccount",
+      value: ClawbackVestingAccount.encode(message).finish()
+    };
+  }
+};
+
+// src/private-functions/cosmos/getEncodeObjectFromCosmosMessage.ts
+function getEncodeObjectFromCosmosMessage(message) {
+  const msgJson = JSON.parse(message.msg ?? "");
+  if (message.msgTypeUrl === "/ibc.applications.transfer.v1.MsgTransfer") {
+    return {
+      typeUrl: "/ibc.applications.transfer.v1.MsgTransfer",
+      value: MsgTransfer.fromJSON({
+        sourcePort: msgJson.source_port,
+        sourceChannel: msgJson.source_channel,
+        token: msgJson.token,
+        sender: msgJson.sender,
+        receiver: msgJson.receiver,
+        timeoutHeight: msgJson.timeout_height,
+        timeoutTimestamp: msgJson.timeout_timestamp,
+        memo: msgJson.memo
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/cosmwasm.wasm.v1.MsgExecuteContract") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgExecuteContract.fromPartial({
+        sender: msgJson.sender,
+        contract: msgJson.contract,
+        msg: toUtf8(JSON.stringify(msgJson.msg)),
+        funds: msgJson.funds
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/cosmos.bank.v1beta1.MsgSend") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgSend.fromPartial({
+        fromAddress: msgJson.from_address,
+        toAddress: msgJson.to_address,
+        amount: msgJson.amount
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/circle.cctp.v1.MsgDepositForBurn") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgDepositForBurn.fromAmino(msgJson)
+    };
+  }
+  if (message.msgTypeUrl === "/circle.cctp.v1.MsgDepositForBurnWithCaller") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgDepositForBurnWithCaller.fromAmino(msgJson)
+    };
+  }
+  if (message.msgTypeUrl === "/initia.move.v1.MsgExecute") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgExecute.fromPartial({
+        sender: msgJson.sender,
+        moduleAddress: msgJson.module_address,
+        moduleName: msgJson.module_name,
+        functionName: msgJson.function_name,
+        args: msgJson.args
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/opinit.ophost.v1.MsgInitiateTokenDeposit") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgInitiateTokenDeposit.fromPartial({
+        sender: msgJson.sender,
+        to: msgJson.to,
+        amount: msgJson.amount,
+        bridgeId: msgJson.bridge_id
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/evmos.vesting.v2.ClawbackVestingAccount") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: ClawbackVestingAccount.fromPartial({
+        baseVestingAccount: msgJson.base_vesting_account,
+        funderAddress: msgJson.funder_address,
+        lockupPeriods: msgJson.lockup_periods,
+        startTime: msgJson.start_time,
+        vestingPeriods: msgJson.vesting_periods
+      })
+    };
+  }
+  return {
+    typeUrl: message.msgTypeUrl ?? "",
+    value: msgJson
+  };
+}
+function getEncodeObjectFromCosmosMessageInjective(message) {
+  const msgJson = JSON.parse(message.msg ?? "");
+  if (message.msgTypeUrl === "/ibc.applications.transfer.v1.MsgTransfer") {
+    return MsgTransfer$1.fromJSON({
+      port: msgJson.source_port,
+      channelId: msgJson.source_channel,
+      amount: msgJson.token,
+      sender: msgJson.sender,
+      receiver: msgJson.receiver,
+      timeout: msgJson.timeout_timestamp,
+      memo: msgJson.memo
+    });
+  }
+  if (message.msgTypeUrl === "/cosmwasm.wasm.v1.MsgExecuteContract") {
+    return MsgExecuteContractCompat.fromJSON({
+      sender: msgJson.sender,
+      contractAddress: msgJson.contract,
+      msg: msgJson.msg,
+      funds: msgJson.funds
+    });
+  }
+  throw new Error("Unsupported message type");
+}
+function createTransaction({
+  chainId,
+  message,
+  timeoutHeight,
+  memo = "",
+  fee = DEFAULT_STD_FEE,
+  signMode = 1,
+  pubKey,
+  accountNumber,
+  sequence
+}) {
+  const signers = {
+    pubKey,
+    accountNumber,
+    sequence
+  };
+  return 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) => 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 TxRaw.fromPartial({
+    bodyBytes: directSignResponse.signed.bodyBytes,
+    authInfoBytes: directSignResponse.signed.authInfoBytes,
+    signatures: [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 ChainRestTendermintApi(restEndpoint);
+  const latestBlock = await chainRestTendermintApi.fetchLatestBlock();
+  const latestHeight = latestBlock.header.height;
+  const timeoutHeight = new BigNumberInBase(latestHeight).plus(DEFAULT_BLOCK_TIMEOUT_HEIGHT);
+  const pk = Buffer.from(accountFromSigner.pubkey).toString("base64");
+  const messages2 = cosmosMsgs.map(
+    (cosmosMsg) => 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 TxRaw.fromPartial({
+    bodyBytes: directSignResponse.signed.bodyBytes,
+    authInfoBytes: directSignResponse.signed.authInfoBytes,
+    signatures: [fromBase64(directSignResponse.signature.signature)]
+  });
+};
+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;
+  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) => getEncodeObjectFromCosmosMessage(cosmosMsg));
+  const txBodyEncodeObject = {
+    typeUrl: "/cosmos.tx.v1beta1.TxBody",
+    value: {
+      messages: messages2
+    }
+  };
+  const txBodyBytes = ClientState.registry.encode(txBodyEncodeObject);
+  const gasLimit = Int53.fromString(fee.gas).toNumber();
+  const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainId);
+  const authInfoBytes = makeAuthInfoBytes(
+    [{ pubkey: pubkeyAny, sequence }],
+    fee.amount,
+    gasLimit,
+    fee.granter,
+    fee.payer
+  );
+  const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber);
+  const { signature, signed } = await signer.signDirect(signerAddress, signDoc);
+  return TxRaw.fromPartial({
+    bodyBytes: signed.bodyBytes,
+    authInfoBytes: signed.authInfoBytes,
+    signatures: [fromBase64(signature.signature)]
+  });
+};
+var signCosmosMessageAmino = async (options) => {
+  const {
+    signer,
+    signerAddress,
+    chainId,
+    cosmosMsgs,
+    fee,
+    signerData: { accountNumber, sequence, chainId: signerChainId }
+  } = options;
+  const accounts = await signer.getAccounts();
+  const accountFromSigner = accounts.find((account) => account.address === signerAddress);
+  if (!accountFromSigner) {
+    throw new Error("signCosmosMessageAmino: failed to retrieve account from signer");
+  }
+  const messages2 = cosmosMsgs.map((cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg));
+  const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+  const msgs = messages2.map((msg) => ClientState.aminoTypes.toAmino(msg));
+  console.log("sign cosmos message amino", msgs, fee, signerChainId, "", accountNumber, sequence);
+  const signDoc = makeSignDoc$1(msgs, fee, signerChainId, "", accountNumber, sequence);
+  const { signature, signed } = await signer.signAmino(signerAddress, signDoc);
+  const signedTxBody = {
+    messages: signed.msgs.map((msg) => ClientState.aminoTypes.fromAmino(msg)),
+    memo: signed.memo
+  };
+  signedTxBody.messages[0].value.memo = messages2[0].value.memo;
+  const signedTxBodyEncodeObject = {
+    typeUrl: "/cosmos.tx.v1beta1.TxBody",
+    value: signedTxBody
+  };
+  const signedTxBodyBytes = ClientState.registry.encode(signedTxBodyEncodeObject);
+  const signedGasLimit = Int53.fromString(signed.fee.gas).toNumber();
+  const signedSequence = Int53.fromString(signed.sequence).toNumber();
+  const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainId);
+  const signedAuthInfoBytes = makeAuthInfoBytes(
+    [{ pubkey: pubkeyAny, sequence: signedSequence }],
+    signed.fee.amount,
+    signedGasLimit,
+    signed.fee.granter,
+    signed.fee.payer,
+    signMode
+  );
+  return TxRaw.fromPartial({
+    bodyBytes: signedTxBodyBytes,
+    authInfoBytes: signedAuthInfoBytes,
+    signatures: [fromBase64(signature.signature)]
+  });
+};
+
+// src/private-functions/cosmos/executeCosmosTransaction.ts
+var executeCosmosTransaction = 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 = 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 { stargateClient, signer } = await getSigningStargateClient({
+    chainId,
+    getOfflineSigner: options?.getCosmosSigner
+  });
+  if (!currentUserAddress) {
+    throw new Error(
+      `executeCosmosTransaction error: invalid address for chain '${tx.cosmosTx?.chainId}'`
+    );
+  }
+  const accounts = await signer.getAccounts();
+  const accountFromSigner = accounts.find((account) => account.address === currentUserAddress);
+  if (!accountFromSigner) {
+    throw new Error("executeCosmosTransaction error: failed to retrieve account from signer");
+  }
+  const fee = gasUsed?.fee;
+  if (!fee) {
+    throw new Error("executeCosmosTransaction error: failed to retrieve fee from gas");
+  }
+  const { accountNumber, sequence } = await getAccountNumberAndSequence(
+    currentUserAddress,
+    chainId
+  );
+  let rawTx;
+  const commonRawTxBody = {
+    signerAddress: currentUserAddress,
+    chainId,
+    cosmosMsgs: messages2,
+    fee,
+    signerData: {
+      accountNumber,
+      sequence,
+      chainId
+    }
+  };
+  if (isOfflineDirectSigner(signer)) {
+    rawTx = await signCosmosMessageDirect({
+      ...commonRawTxBody,
+      signer
+    });
+  } else {
+    rawTx = await signCosmosMessageAmino({ ...commonRawTxBody, signer });
+  }
+  options?.onTransactionSigned?.({
+    chainId
+  });
+  const txBytes = TxRaw.encode(rawTx).finish();
+  const txResponse = await stargateClient.broadcastTx(txBytes);
+  return {
+    chainId: tx?.cosmosTx?.chainId ?? "",
+    txHash: txResponse.transactionHash
+  };
+};
+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) => {
+  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 || ClientState.getEvmSigner;
+  if (!getEvmSigner) {
+    throw new Error("Unable to get EVM signer");
+  }
+  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) {
+    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
+      });
+      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"
+    });
+  }
+  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 executeSvmTransaction = async (tx, options) => {
+  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 || ClientState.getSvmSigner;
+  if (!getSvmSigner) {
+    throw new Error(
+      "executeRoute error: 'getSVMSigner' is not provided or configured in skip router"
+    );
+  }
+  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);
+  const endpoint = await getRpcEndpointForChain(svmTx.chainId);
+  const connection = new Connection(endpoint);
+  let signature;
+  if ("signTransaction" in signer) {
+    const signedTx = await signer.signTransaction(transaction);
+    options?.onTransactionSigned?.({ chainId: svmTx.chainId });
+    const serializedTx = signedTx.serialize();
+    await submitTransaction({
+      chainId: svmTx.chainId,
+      tx: serializedTx.toString("base64")
+    }).then((res) => {
+      signature = res?.txHash;
+    });
+    const rpcSig = await connection.sendRawTransaction(serializedTx, {
+      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 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 DEFAULT_GAS_MULTIPLIER = 1.5;
+async function getCosmosGasAmountForMessage(client, signerAddress, chainId, messages2, encodedMsgs, multiplier = DEFAULT_GAS_MULTIPLIER) {
+  if (!messages2 && !encodedMsgs) {
+    throw new Error("Either message or encodedMsg must be provided");
+  }
+  const _encodedMsgs = messages2?.map((message) => getEncodeObjectFromCosmosMessage(message));
+  encodedMsgs = encodedMsgs || _encodedMsgs;
+  if (!encodedMsgs) {
+    throw new Error("Either message or encodedMsg must be provided");
+  }
+  if (chainId.includes("evmos") || chainId.includes("injective") || chainId.includes("dymension") || process?.env.NODE_ENV === "test") {
+    if (messages2?.find((i) => i.msgTypeUrl === "/cosmwasm.wasm.v1.MsgExecuteContract")) {
+      return "2400000";
+    }
+    return "280000";
+  }
+  const estimatedGas = await client.simulate(signerAddress, encodedMsgs, "");
+  const estimatedGasWithBuffer = estimatedGas * multiplier;
+  return Math.ceil(estimatedGasWithBuffer).toFixed(0);
+}
+
+// src/private-functions/cosmos/validateCosmosGasBalance.ts
+var validateCosmosGasBalance = async ({
+  chainId,
+  signerAddress,
+  messages: messages2,
+  getFallbackGasAmount,
+  getOfflineSigner,
+  txIndex,
+  simulate
+}) => {
+  const skipAssets = (await ClientState.getSkipAssets({ chainId }))?.[chainId];
+  const skipChains = await ClientState.getSkipChains();
+  const chain = skipChains?.find((c) => c.chainId === chainId);
+  if (!chain) {
+    throw new Error(`failed to find chain id for '${chainId}'`);
+  }
+  const { feeAssets } = chain;
+  if (!feeAssets) {
+    throw new Error(`failed to find fee assets for chain '${chainId}'`);
+  }
+  const estimatedGasAmount = await (async () => {
+    try {
+      if (!simulate) throw new Error("simulate");
+      if (txIndex !== 0 && chainId === "noble-1") {
+        return "0";
+      }
+      const { stargateClient } = await getSigningStargateClient({
+        chainId,
+        getOfflineSigner
+      });
+      const estimatedGas = await getCosmosGasAmountForMessage(
+        stargateClient,
+        signerAddress,
+        chainId,
+        messages2
+      );
+      return estimatedGas;
+    } catch (e) {
+      const error = e;
+      if (error.message === "simulate" && !getFallbackGasAmount) {
+        throw new Error(`unable to get gas amount for ${chainId}'s message(s)`);
+      }
+      if (getFallbackGasAmount) {
+        const fallbackGasAmount = await getFallbackGasAmount(chainId, "cosmos" /* Cosmos */);
+        if (!fallbackGasAmount) {
+          throw new Error(`unable to estimate gas for message(s) ${messages2}`);
+        }
+        return String(fallbackGasAmount);
+      }
+      throw error;
+    }
+  })();
+  const fees = feeAssets.map((asset) => {
+    const gasPrice = (() => {
+      if (!asset?.gasPrice) return void 0;
+      let price = asset.gasPrice.average;
+      if (price === "") {
+        price = asset.gasPrice.high;
+      }
+      if (price === "") {
+        price = asset.gasPrice.low;
+      }
+      if (!price) return;
+      return new GasPrice(
+        Decimal.fromUserInput(BigNumber(price).toFixed(), 18),
+        asset?.denom ?? ""
+      );
+    })();
+    if (!gasPrice) {
+      return null;
+    }
+    if (chainId === "noble-1") {
+      const fee = calculateFee(2e5, gasPrice);
+      return fee;
+    }
+    return calculateFee(Math.ceil(parseFloat(estimatedGasAmount)), gasPrice);
+  });
+  const feeBalance = await balances({
+    chains: {
+      [chainId]: {
+        address: signerAddress,
+        denoms: feeAssets.map((asset) => asset.denom ?? "")
+      }
+    }
+  });
+  const validatedAssets = feeAssets.map((asset, index) => {
+    const chainAsset = skipAssets?.find((x) => x.denom === asset.denom);
+    const symbol = chainAsset?.recommendedSymbol?.toUpperCase();
+    const decimal = Number(chainAsset?.decimals);
+    if (!chainAsset) {
+      return {
+        error: `(${chain?.prettyName}) Unable to find asset for ${asset.denom}`
+      };
+    }
+    if (isNaN(decimal))
+      return {
+        error: `(${chain?.prettyName}) Unable to find decimal for ${symbol}`
+      };
+    const fee = fees[index];
+    if (!fee) {
+      return {
+        error: `(${chain?.prettyName}) Unable to calculate fee for ${symbol}`,
+        asset
+      };
+    }
+    if (txIndex !== 0 && chainId === "noble-1") {
+      return {
+        error: null,
+        asset,
+        fee
+      };
+    }
+    let balance = feeBalance?.chains?.[chainId]?.denoms?.[asset?.denom ?? ""];
+    if (!balance) {
+      balance = {
+        amount: "0",
+        formattedAmount: "0"
+      };
+    }
+    if (!fee.amount[0]?.amount) {
+      return {
+        error: `(${chain?.prettyName}) Unable to get fee for ${symbol}`,
+        asset
+      };
+    }
+    if (parseInt(balance?.amount ?? "") < parseInt(fee.amount[0]?.amount)) {
+      const userAmount = new BigNumber(parseFloat(balance?.amount ?? "")).shiftedBy(-decimal).toFixed(decimal);
+      const feeAmount = new BigNumber(parseFloat(fee.amount[0]?.amount)).shiftedBy(-decimal).toFixed(decimal);
+      return {
+        error: `Insufficient balance for gas on ${chain?.prettyName}. Need ${feeAmount} ${symbol} but only have ${userAmount} ${symbol}.`,
+        asset
+      };
+    }
+    return {
+      error: null,
+      asset,
+      fee
+    };
+  });
+  const feeUsed = validatedAssets.find((res) => res?.error === null);
+  if (!feeUsed) {
+    if (validatedAssets.length > 1) {
+      throw new Error(
+        validatedAssets[0]?.error || `Insufficient fee token to initiate transfer on ${chainId}.`
+      );
+    }
+    throw new Error(
+      validatedAssets[0]?.error || `Insufficient fee token to initiate transfer on ${chainId}.`
+    );
+  }
+  return feeUsed;
+};
+var validateEvmTokenApproval = async ({
+  requiredErc20Approvals,
+  signer,
+  chain,
+  gasBalance,
+  tx,
+  useUnlimitedApproval
+}) => {
+  if (!signer.account?.address) {
+    throw new Error("validateEvmGasBalance: Signer address not found");
+  }
+  for (const requiredApproval of requiredErc20Approvals) {
+    const extendedSigner = signer.extend(publicActions);
+    const allowance = await extendedSigner.readContract({
+      address: requiredApproval.tokenContract,
+      abi: erc20ABI,
+      functionName: "allowance",
+      args: [signer.account?.address, requiredApproval.spender]
+    });
+    if (allowance > BigInt(requiredApproval.amount)) {
+      continue;
+    }
+    const fee = await extendedSigner.estimateFeesPerGas();
+    const allowanceGasFee = BigInt(fee.maxFeePerGas) * BigInt(1e5);
+    if (!gasBalance) {
+      const chainAssets = (await ClientState.getSkipAssets({ chainId: tx.chainId }))[tx.chainId];
+      const nativeAsset = chainAssets?.find((x) => x.denom.includes("-native"));
+      const zeroAddressAsset = chainAssets?.find(
+        (x) => x.denom.toLowerCase() === "0x0000000000000000000000000000000000000000"
+      );
+      const asset = nativeAsset || zeroAddressAsset;
+      if (!asset?.decimals) {
+        throw new Error(
+          `Insufficient balance for gas on ${chain.prettyName}. Need ${allowanceGasFee} gwei.`
+        );
+      }
+      const formattedGasAmount = formatUnits(allowanceGasFee, asset?.decimals);
+      throw new Error(
+        `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol}.`
+      );
+    }
+    if (BigNumber(gasBalance.amount).lt(Number(allowanceGasFee))) {
+      const chainAssets = (await ClientState.getSkipAssets({ chainId: tx.chainId }))[tx.chainId];
+      const asset = chainAssets?.find(
+        (x) => x.denom.includes("-native") || x.denom.toLowerCase() === "0x0000000000000000000000000000000000000000"
+      );
+      if (!asset?.decimals) {
+        return {
+          error: `Insufficient balance for gas on ${chain.prettyName}. Need ${allowanceGasFee} gwei but only have ${gasBalance.amount} gwei.`,
+          asset: null,
+          fee: null
+        };
+      }
+      const formattedGasAmount = formatUnits(allowanceGasFee, asset?.decimals);
+      return {
+        error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol} but only have ${gasBalance.formattedAmount} ${asset.symbol}.`,
+        asset: null,
+        fee: null
+      };
+    }
+    const txHash = await extendedSigner.writeContract({
+      account: signer.account,
+      address: requiredApproval.tokenContract,
+      abi: erc20ABI,
+      functionName: "approve",
+      args: [
+        requiredApproval.spender,
+        useUnlimitedApproval ? maxUint256 : BigInt(requiredApproval.amount) + BigInt(1e3)
+      ],
+      chain: signer.chain
+    });
+    const receipt = await extendedSigner.waitForTransactionReceipt({
+      hash: txHash
+    });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `executeEVMTransaction error: evm tx reverted for hash ${receipt.transactionHash}`
+      );
+    }
+  }
+};
+async function getEVMGasAmountForMessage(signer, tx, getFallbackGasAmount) {
+  const { to, data, value } = tx;
+  if (!signer.account) throw new Error("estimateGasForEvmTx: No account found");
+  const extendedSigner = signer.extend(publicActions);
+  const fee = await extendedSigner.estimateFeesPerGas();
+  try {
+    const gasAmount = await extendedSigner.estimateGas({
+      account: signer.account,
+      to,
+      data: `0x${data}`,
+      value: value === "" ? void 0 : BigInt(value ?? "")
+    });
+    return gasAmount * fee.maxFeePerGas;
+  } catch (error) {
+    const fallbackGasAmount = await getFallbackGasAmount?.(tx.chainId ?? "", "evm" /* Evm */);
+    if (fallbackGasAmount) {
+      return BigInt(fallbackGasAmount) * fee.maxFeePerGas;
+    }
+    throw error;
+  }
+}
+
+// src/private-functions/evm/validateEvmGasBalance.ts
+var validateEvmGasBalance = async ({
+  signer,
+  tx,
+  getFallbackGasAmount,
+  useUnlimitedApproval
+}) => {
+  const chainId = tx?.chainId ?? "";
+  const skipAssets = (await ClientState.getSkipAssets({ chainId }))?.[chainId];
+  const skipChains = await ClientState.getSkipChains();
+  const chain = skipChains?.find?.((chain2) => chain2.chainId === chainId);
+  if (!chain) {
+    throw new Error(`failed to find chain for chainId: '${chainId}'`);
+  }
+  if (!signer.account?.address) {
+    throw new Error("validateEvmGasBalance: Signer address not found");
+  }
+  const skipBalances = (await balances({
+    chains: {
+      [tx?.chainId ?? ""]: {
+        address: signer.account?.address
+      }
+    }
+  }))?.chains?.[tx?.chainId ?? ""]?.denoms;
+  const nativeGasBalance = skipBalances && Object.entries(skipBalances).find(([denom]) => denom.includes("-native"))?.[1];
+  const zeroAddressGasBalance = skipBalances && Object.entries(skipBalances).find(
+    ([denom]) => denom.toLowerCase() === "0x0000000000000000000000000000000000000000"
+  )?.[1];
+  const gasBalance = nativeGasBalance || zeroAddressGasBalance;
+  const { requiredErc20Approvals } = tx;
+  if (requiredErc20Approvals) {
+    try {
+      await validateEvmTokenApproval({
+        requiredErc20Approvals,
+        signer,
+        chain,
+        gasBalance,
+        tx,
+        useUnlimitedApproval
+      });
+    } catch (error) {
+      const err = error;
+      return {
+        error: err.message,
+        asset: null,
+        fee: null
+      };
+    }
+  }
+  const gasAmount = await getEVMGasAmountForMessage(signer, tx, getFallbackGasAmount);
+  if (!gasBalance) {
+    const nativeAsset = skipAssets?.find((x) => x.denom?.includes("-native"));
+    const zeroAddressAsset = skipAssets?.find(
+      (x) => x.denom?.toLowerCase() === "0x0000000000000000000000000000000000000000"
+    );
+    const asset = nativeAsset || zeroAddressAsset;
+    if (!asset?.decimals) {
+      return {
+        error: `Insufficient balance for gas on ${chain.prettyName}. Need ${gasAmount} gwei.`,
+        asset: null,
+        fee: null
+      };
+    }
+    const formattedGasAmount = formatUnits(gasAmount, asset?.decimals);
+    return {
+      error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol}.`,
+      asset: null,
+      fee: null
+    };
+  }
+  if (BigNumber(gasBalance.amount ?? "").lt(Number(gasAmount))) {
+    const asset = skipAssets?.find(
+      (x) => x.denom?.includes("-native") || x.denom?.toLowerCase() === "0x0000000000000000000000000000000000000000"
+    );
+    if (!asset?.decimals) {
+      return {
+        error: `Insufficient balance for gas on ${chain.prettyName}. Need ${gasAmount} gwei but only have ${gasBalance.amount} gwei.`,
+        asset: null,
+        fee: null
+      };
+    }
+    const formattedGasAmount = formatUnits(gasAmount, asset?.decimals);
+    return {
+      error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol} but only have ${gasBalance.formattedAmount} ${asset.symbol}.`,
+      asset: null,
+      fee: null
+    };
+  }
+};
+var validateSvmGasBalance = async ({
+  tx
+}) => {
+  if (!tx) throw new Error("Transaction is required");
+  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,
+  useUnlimitedApproval
+}) => {
+  if (txs.every((tx) => "cosmosTx" in tx === void 0) || txs.every((tx) => "svmTx" in tx === void 0)) {
+    return;
+  }
+  onValidateGasBalance?.({
+    status: "pending"
+  });
+  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 ?? ""))) {
+        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
+          });
+          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 ?? ""))) {
+        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 ?? ""))) {
+        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"
+    });
+    ClientState.validateGasResults = validateResult;
+    throw new Error(`${txError.error}`);
+  }
+  onValidateGasBalance?.({
+    status: "completed"
+  });
+  ClientState.validateGasResults = validateResult;
+};
+
+// src/private-functions/waitForTransaction.ts
+var waitForTransaction = async ({
+  chainId,
+  txHash,
+  onTransactionTracked
+}) => {
+  const { explorerLink } = await trackTransaction({
+    chainId,
+    txHash
+  });
+  await onTransactionTracked?.({ txHash, chainId, explorerLink });
+  while (true) {
+    const txStatusResponse = await transactionStatus({
+      chainId,
+      txHash
+    });
+    if (txStatusResponse.state === "STATE_COMPLETED_SUCCESS") {
+      return txStatusResponse;
+    }
+    if (txStatusResponse.state === "STATE_COMPLETED_ERROR") {
+      throw new Error(`${txStatusResponse.error?.type}: ${txStatusResponse.error?.message}`);
+    }
+    if (txStatusResponse.state === "STATE_ABANDONED") {
+      throw new Error("Tracking for the transaction has been abandoned");
+    }
+    await wait(1e3);
+  }
+};
+
+// src/private-functions/executeTransactions.ts
+var executeTransactions = async (options) => {
+  const {
+    txs,
+    onTransactionBroadcast,
+    onTransactionCompleted,
+    simulate = true,
+    batchSimulate = 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 GAS_STATION_CHAIN_IDS.includes(item?.chainId ?? "") && array[i - 1]?.chainType === "evm";
+  });
+  ClientState.validateGasResults = void 0;
+  const validateChainIds = !batchSimulate ? chainIds.map((x) => x?.chainId ?? "") : isGasStationSourceEVM ? GAS_STATION_CHAIN_IDS : [];
+  await validateGasBalances({
+    txs,
+    getFallbackGasAmount: options.getFallbackGasAmount,
+    getCosmosSigner: options.getCosmosSigner,
+    getEvmSigner: options.getEvmSigner,
+    onValidateGasBalance: options.onValidateGasBalance,
+    simulate,
+    disabledChainIds: validateChainIds
+  });
+  const validateEnabledChainIds = async (chainId) => {
+    await validateGasBalances({
+      txs,
+      getFallbackGasAmount: options.getFallbackGasAmount,
+      getCosmosSigner: options.getCosmosSigner,
+      getEvmSigner: options.getEvmSigner,
+      onValidateGasBalance: options.onValidateGasBalance,
+      simulate,
+      enabledChainIds: !batchSimulate ? [chainId] : validateChainIds
+    });
+  };
+  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;
+    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);
+      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 waitForTransaction({
+      ...txResult,
+      onTransactionTracked: options.onTransactionTracked
+    });
+    await onTransactionCompleted?.({
+      chainId: txResult.chainId,
+      txHash: txResult.txHash,
+      status: txStatusResponse
+    });
+  }
+};
+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 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: ApiState.chainIdsToAffiliates
+  });
+  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 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);
+};
+
+export { executeRoute };