@skip-go/client 0.4.3

package/dist/index.js

@@ -0,0 +1,2874 @@
+'use strict';
+
+var chunkJRIEAGIQ_js = require('./chunk-JRIEAGIQ.js');
+var chunkPV2ELBDQ_js = require('./chunk-PV2ELBDQ.js');
+var chunk6AMBIQDN_js = require('./chunk-6AMBIQDN.js');
+var chunk6FNC3XMI_js = require('./chunk-6FNC3XMI.js');
+var amino = require('@cosmjs/amino');
+var cosmwasmStargate = require('@cosmjs/cosmwasm-stargate');
+var encoding = require('@cosmjs/encoding');
+var math = require('@cosmjs/math');
+var protoSigning = require('@cosmjs/proto-signing');
+require('cosmjs-types/cosmos/crypto/multisig/keys');
+var keys = require('cosmjs-types/cosmos/crypto/secp256k1/keys');
+var any = require('cosmjs-types/google/protobuf/any');
+var stargate = require('@cosmjs/stargate');
+var rest = require('@injectivelabs/sdk-ts/dist/cjs/client/chain/rest');
+var utils = require('@injectivelabs/utils');
+var axios2 = require('axios');
+var signing = require('cosmjs-types/cosmos/tx/signing/v1beta1/signing');
+var tx$1 = require('cosmjs-types/cosmos/tx/v1beta1/tx');
+var tx = require('cosmjs-types/cosmwasm/wasm/v1/tx');
+var viem = require('viem');
+var chainRegistry = require('chain-registry');
+var initiaRegistry = require('@initia/initia-registry');
+var coreProtoTs = require('@injectivelabs/core-proto-ts');
+var tx$2 = require('@injectivelabs/sdk-ts/dist/cjs/core/modules/tx/utils/tx');
+var keccak256 = require('keccak256');
+var web3_js = require('@solana/web3.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var axios2__default = /*#__PURE__*/_interopDefault(axios2);
+var chainRegistry__namespace = /*#__PURE__*/_interopNamespace(chainRegistry);
+var initiaRegistry__namespace = /*#__PURE__*/_interopNamespace(initiaRegistry);
+var keccak256__default = /*#__PURE__*/_interopDefault(keccak256);
+
+function isEthSecp256k1Pubkey(pubkey) {
+  return pubkey.type === "ethermint/PubKeyEthSecp256k1";
+}
+var pubkeyType = chunk6FNC3XMI_js.__spreadValues({
+  ethsecp256k1: "ethermint/PubKeyEthSecp256k1"
+}, amino.pubkeyType);
+
+// src/amino/encoding.ts
+function encodeEthSecp256k1Pubkey(pubkey) {
+  if (pubkey.length !== 33 || pubkey[0] !== 2 && pubkey[0] !== 3) {
+    throw new Error(
+      "Public key must be compressed secp256k1, i.e. 33 bytes starting with 0x02 or 0x03"
+    );
+  }
+  return {
+    type: pubkeyType.ethsecp256k1,
+    value: encoding.toBase64(pubkey)
+  };
+}
+
+// src/proto-signing/pubkey.ts
+function makePubkeyAnyFromAccount(account, chainId) {
+  const algo = `${account.algo}`;
+  const isEthSecp256k1 = algo === "eth_secp256k1" || algo === "ethsecp256k1";
+  const pubkey = isEthSecp256k1 ? encodeEthSecp256k1Pubkey(account.pubkey) : amino.encodeSecp256k1Pubkey(account.pubkey);
+  const pubkeyAny = encodePubkeyToAny(pubkey, chainId);
+  return pubkeyAny;
+}
+function encodePubkeyToAny(pubkey, chainId) {
+  if (isEthSecp256k1Pubkey(pubkey)) {
+    const pubkeyProto = keys.PubKey.fromPartial({
+      key: encoding.fromBase64(pubkey.value)
+    });
+    let typeUrl = "";
+    if (chainId == null ? void 0 : chainId.includes("injective")) {
+      typeUrl = "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
+    } else {
+      typeUrl = "/ethermint.crypto.v1.ethsecp256k1.PubKey";
+    }
+    return any.Any.fromPartial({
+      typeUrl,
+      value: Uint8Array.from(keys.PubKey.encode(pubkeyProto).finish())
+    });
+  } else {
+    return protoSigning.encodePubkey(pubkey);
+  }
+}
+var DYDX_CHAIN = {
+  $schema: "../chain.schema.json",
+  chain_name: "dydx",
+  status: "live",
+  website: "https://dydx.exchange/",
+  network_type: "mainnet",
+  pretty_name: "dYdX Protocol",
+  chain_id: "dydx-mainnet-1",
+  bech32_prefix: "dydx",
+  daemon_name: "dydxprotocold",
+  node_home: "$HOME/.dydxprotocol",
+  key_algos: ["secp256k1"],
+  slip44: 118,
+  fees: {
+    fee_tokens: [
+      {
+        denom: "adydx",
+        fixed_min_gas_price: 125e8,
+        low_gas_price: 125e8,
+        average_gas_price: 125e8,
+        high_gas_price: 2e10
+      },
+      {
+        denom: "ibc/8E27BA2D5493AF5636760E354E46004562C46AB7EC0CC4C1CA14E9E20E2545B5",
+        fixed_min_gas_price: 0.025,
+        low_gas_price: 0.025,
+        average_gas_price: 0.025,
+        high_gas_price: 0.03
+      }
+    ]
+  },
+  staking: {
+    staking_tokens: [
+      {
+        denom: "adydx"
+      }
+    ]
+  },
+  codebase: {
+    git_repo: "https://github.com/dydxprotocol/v4-chain/",
+    recommended_version: "v1.0.0",
+    compatible_versions: ["v1.0.0"],
+    cosmos_sdk_version: "v0.47.4",
+    cosmwasm_enabled: false,
+    genesis: {
+      genesis_url: "https://raw.githubusercontent.com/dydxopsdao/networks/main/dydx-mainnet-1/genesis.json"
+    },
+    versions: [
+      {
+        name: "v1",
+        recommended_version: "v1.0.0",
+        compatible_versions: ["v1.0.0"],
+        cosmos_sdk_version: "v0.47.4"
+      }
+    ]
+  },
+  logo_URIs: {
+    png: "https://raw.githubusercontent.com/cosmos/chain-registry/master/dydx/images/dydx.png",
+    svg: "https://raw.githubusercontent.com/cosmos/chain-registry/master/dydx/images/dydx.svg"
+  },
+  peers: {
+    seeds: [
+      {
+        id: "20e1000e88125698264454a884812746c2eb4807",
+        address: "seeds.lavenderfive.com:23856",
+        provider: "Lavender.Five Nodes \u{1F41D}"
+      },
+      {
+        id: "ebc272824924ea1a27ea3183dd0b9ba713494f83",
+        address: "dydx-mainnet-seed.autostake.com:27366",
+        provider: "AutoStake \u{1F6E1}\uFE0F Slash Protected"
+      },
+      {
+        id: "65b740ee326c9260c30af1f044e9cda63c73f7c1",
+        address: "seeds.kingnodes.net:23856",
+        provider: "Kingnodes"
+      },
+      {
+        id: "4c30c8a95e26b07b249813b677caab28bf0c54eb",
+        address: "rpc.dydx.nodestake.top:666",
+        provider: "NodeStake"
+      },
+      {
+        id: "400f3d9e30b69e78a7fb891f60d76fa3c73f0ecc",
+        address: "dydx.rpc.kjnodes.com:17059",
+        provider: "kjnodes"
+      },
+      {
+        id: "e1b058e5cfa2b836ddaa496b10911da62dcf182e",
+        address: "dydx-seed-de.allnodes.me:26656",
+        provider: "Allnodes \u26A1\uFE0F Nodes & Staking"
+      },
+      {
+        id: "e726816f42831689eab9378d5d577f1d06d25716",
+        address: "dydx-seed-us.allnodes.me:26656",
+        provider: "Allnodes \u26A1\uFE0F Nodes & Staking"
+      }
+    ],
+    persistent_peers: [
+      {
+        id: "ebc272824924ea1a27ea3183dd0b9ba713494f83",
+        address: "dydx-mainnet-peer.autostake.com:27366",
+        provider: "AutoStake \u{1F6E1}\uFE0F Slash Protected"
+      }
+    ]
+  },
+  apis: {
+    rpc: [
+      {
+        address: "https://dydx-rpc.lavenderfive.com:443",
+        provider: "Lavender.Five Nodes \u{1F41D}"
+      },
+      {
+        address: "https://dydx-mainnet-rpc.autostake.com:443",
+        provider: "AutoStake \u{1F6E1}\uFE0F Slash Protected"
+      },
+      {
+        address: "https://rpc-dydx.ecostake.com:443",
+        provider: "ecostake"
+      },
+      {
+        address: "https://rpc.dydx.nodestake.top:443",
+        provider: "NodeStake"
+      },
+      {
+        address: "https://dydx.rpc.kjnodes.com:443",
+        provider: "kjnodes"
+      },
+      {
+        address: "https://dydx-rpc.publicnode.com:443",
+        provider: "Allnodes \u26A1\uFE0F Nodes & Staking"
+      }
+    ],
+    rest: [
+      {
+        address: "https://dydx-api.lavenderfive.com:443",
+        provider: "Lavender.Five Nodes \u{1F41D}"
+      },
+      {
+        address: "https://dydx-mainnet-lcd.autostake.com:443",
+        provider: "AutoStake \u{1F6E1}\uFE0F Slash Protected"
+      },
+      {
+        address: "https://rest-dydx.ecostake.com:443",
+        provider: "ecostake"
+      },
+      {
+        address: "https://api.dydx.nodestake.top:443",
+        provider: "NodeStake"
+      },
+      {
+        address: "https://dydx.api.kjnodes.com:443",
+        provider: "kjnodes"
+      },
+      {
+        address: "https://dydx-rest.publicnode.com",
+        provider: "Allnodes \u26A1\uFE0F Nodes & Staking"
+      }
+    ],
+    grpc: [
+      {
+        address: "https://dydx-grpc.lavenderfive.com",
+        provider: "Lavender.Five Nodes \u{1F41D}"
+      },
+      {
+        address: "dydx-mainnet-grpc.autostake.com:443",
+        provider: "AutoStake \u{1F6E1}\uFE0F Slash Protected"
+      },
+      {
+        address: "https://grpc.dydx.nodestake.top",
+        provider: "NodeStake"
+      },
+      {
+        address: "dydx.grpc.kjnodes.com:443",
+        provider: "kjnodes"
+      },
+      {
+        address: "dydx-grpc.publicnode.com:443",
+        provider: "Allnodes \u26A1\uFE0F Nodes & Staking"
+      }
+    ]
+  },
+  explorers: [
+    {
+      kind: "mintscan",
+      url: "https://www.mintscan.io/dydx",
+      tx_page: "https://www.mintscan.io/dydx/txs/${txHash}",
+      account_page: "https://www.mintscan.io/dydx/account/${accountAddress}"
+    },
+    {
+      kind: "NodeStake",
+      url: "https://explorer.nodestake.top/dydx/",
+      tx_page: "https://explorer.nodestake.top/dydx/txs/${txHash}",
+      account_page: "https://explorer.nodestake.top/dydx/account/${accountAddress}"
+    }
+  ],
+  images: [
+    {
+      png: "https://raw.githubusercontent.com/cosmos/chain-registry/master/dydx/images/dydx.png",
+      svg: "https://raw.githubusercontent.com/cosmos/chain-registry/master/dydx/images/dydx.svg"
+    }
+  ]
+};
+var CELESTIA_CHAIN = {
+  $schema: "../chain.schema.json",
+  chain_name: "celestia",
+  chain_id: "celestia",
+  pretty_name: "Celestia",
+  status: "live",
+  network_type: "mainnet",
+  bech32_prefix: "celestia",
+  daemon_name: "celestia-appd",
+  node_home: "$HOME/.celestia-app",
+  key_algos: ["secp256k1"],
+  slip44: 118,
+  fees: {
+    fee_tokens: [
+      {
+        denom: "utia",
+        fixed_min_gas_price: 0,
+        low_gas_price: 0.1,
+        average_gas_price: 0.2,
+        high_gas_price: 0.4
+      }
+    ]
+  },
+  codebase: {
+    git_repo: "https://github.com/celestiaorg/celestia-app",
+    recommended_version: "v1.3.0",
+    compatible_versions: ["v1.3.0"],
+    genesis: {
+      genesis_url: "https://raw.githubusercontent.com/celestiaorg/networks/master/celestia/genesis.json"
+    },
+    versions: [
+      {
+        name: "v1.3.0",
+        recommended_version: "v1.3.0",
+        compatible_versions: ["v1.3.0"]
+      }
+    ]
+  },
+  peers: {
+    seeds: [
+      {
+        id: "e6116822e1a5e283d8a85d3ec38f4d232274eaf3",
+        address: "consensus-full-seed-1.celestia-bootstrap.net:26656",
+        provider: "Celestia Foundation"
+      },
+      {
+        id: "cf7ac8b19ff56a9d47c75551bd4864883d1e24b5",
+        address: "consensus-full-seed-1.celestia-bootstrap.net:26656",
+        provider: "Celestia Foundation"
+      }
+    ]
+  },
+  apis: {
+    rpc: [
+      {
+        address: "https://public-celestia-rpc.numia.xyz",
+        provider: "Numia"
+      },
+      {
+        address: "https://celestia-rpc.mesa.newmetric.xyz",
+        provider: "Newmetric"
+      },
+      {
+        address: "https://rpc.lunaroasis.net",
+        provider: "Lunar Oasis"
+      }
+    ],
+    rest: [
+      {
+        address: "https://public-celestia-lcd.numia.xyz",
+        provider: "Numia"
+      },
+      {
+        address: "https://celestia-rest.mesa.newmetric.xyz",
+        provider: "Newmetric"
+      },
+      {
+        address: "https://api.lunaroasis.net",
+        provider: "Lunar Oasis"
+      }
+    ]
+  },
+  explorers: [
+    {
+      kind: "Mintscan",
+      url: "https://mintscan.io/celestia",
+      tx_page: "https://mintscan.io/celestia/txs/${txHash}"
+    }
+  ]
+};
+function chains3() {
+  const chains4 = chainRegistry__namespace.chains;
+  if (chains4.findIndex((chain) => chain.chain_id === "dydx-mainnet-1") === -1) {
+    chains4.push(DYDX_CHAIN);
+  }
+  if (chains4.findIndex((chain) => chain.chain_id === "celestia") === -1) {
+    chains4.push(CELESTIA_CHAIN);
+  }
+  return chains4;
+}
+function initiaChains() {
+  const chains4 = initiaRegistry__namespace.chains;
+  return chains4;
+}
+
+// src/codegen/circle/cctp/v1/tx.registry.ts
+var registry = [["/circle.cctp.v1.MsgAcceptOwner", chunkPV2ELBDQ_js.MsgAcceptOwner], ["/circle.cctp.v1.MsgAddRemoteTokenMessenger", chunkPV2ELBDQ_js.MsgAddRemoteTokenMessenger], ["/circle.cctp.v1.MsgDepositForBurn", chunkPV2ELBDQ_js.MsgDepositForBurn], ["/circle.cctp.v1.MsgDepositForBurnWithCaller", chunkPV2ELBDQ_js.MsgDepositForBurnWithCaller], ["/circle.cctp.v1.MsgDisableAttester", chunkPV2ELBDQ_js.MsgDisableAttester], ["/circle.cctp.v1.MsgEnableAttester", chunkPV2ELBDQ_js.MsgEnableAttester], ["/circle.cctp.v1.MsgLinkTokenPair", chunkPV2ELBDQ_js.MsgLinkTokenPair], ["/circle.cctp.v1.MsgPauseBurningAndMinting", chunkPV2ELBDQ_js.MsgPauseBurningAndMinting], ["/circle.cctp.v1.MsgPauseSendingAndReceivingMessages", chunkPV2ELBDQ_js.MsgPauseSendingAndReceivingMessages], ["/circle.cctp.v1.MsgReceiveMessage", chunkPV2ELBDQ_js.MsgReceiveMessage], ["/circle.cctp.v1.MsgRemoveRemoteTokenMessenger", chunkPV2ELBDQ_js.MsgRemoveRemoteTokenMessenger], ["/circle.cctp.v1.MsgReplaceDepositForBurn", chunkPV2ELBDQ_js.MsgReplaceDepositForBurn], ["/circle.cctp.v1.MsgReplaceMessage", chunkPV2ELBDQ_js.MsgReplaceMessage], ["/circle.cctp.v1.MsgSendMessage", chunkPV2ELBDQ_js.MsgSendMessage], ["/circle.cctp.v1.MsgSendMessageWithCaller", chunkPV2ELBDQ_js.MsgSendMessageWithCaller], ["/circle.cctp.v1.MsgUnlinkTokenPair", chunkPV2ELBDQ_js.MsgUnlinkTokenPair], ["/circle.cctp.v1.MsgUnpauseBurningAndMinting", chunkPV2ELBDQ_js.MsgUnpauseBurningAndMinting], ["/circle.cctp.v1.MsgUnpauseSendingAndReceivingMessages", chunkPV2ELBDQ_js.MsgUnpauseSendingAndReceivingMessages], ["/circle.cctp.v1.MsgUpdateOwner", chunkPV2ELBDQ_js.MsgUpdateOwner], ["/circle.cctp.v1.MsgUpdateAttesterManager", chunkPV2ELBDQ_js.MsgUpdateAttesterManager], ["/circle.cctp.v1.MsgUpdateTokenController", chunkPV2ELBDQ_js.MsgUpdateTokenController], ["/circle.cctp.v1.MsgUpdatePauser", chunkPV2ELBDQ_js.MsgUpdatePauser], ["/circle.cctp.v1.MsgUpdateMaxMessageBodySize", chunkPV2ELBDQ_js.MsgUpdateMaxMessageBodySize], ["/circle.cctp.v1.MsgSetMaxBurnAmountPerMessage", chunkPV2ELBDQ_js.MsgSetMaxBurnAmountPerMessage], ["/circle.cctp.v1.MsgUpdateSignatureThreshold", chunkPV2ELBDQ_js.MsgUpdateSignatureThreshold]];
+
+// src/codegen/circle/cctp/v1/tx.amino.ts
+var AminoConverter = {
+  "/circle.cctp.v1.MsgAcceptOwner": {
+    aminoType: "cctp/AcceptOwner",
+    toAmino: chunkPV2ELBDQ_js.MsgAcceptOwner.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgAcceptOwner.fromAmino
+  },
+  "/circle.cctp.v1.MsgAddRemoteTokenMessenger": {
+    aminoType: "cctp/AddRemoteTokenMessenger",
+    toAmino: chunkPV2ELBDQ_js.MsgAddRemoteTokenMessenger.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgAddRemoteTokenMessenger.fromAmino
+  },
+  "/circle.cctp.v1.MsgDepositForBurn": {
+    aminoType: "cctp/DepositForBurn",
+    toAmino: chunkPV2ELBDQ_js.MsgDepositForBurn.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgDepositForBurn.fromAmino
+  },
+  "/circle.cctp.v1.MsgDepositForBurnWithCaller": {
+    aminoType: "cctp/DepositForBurnWithCaller",
+    toAmino: chunkPV2ELBDQ_js.MsgDepositForBurnWithCaller.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgDepositForBurnWithCaller.fromAmino
+  },
+  "/circle.cctp.v1.MsgDisableAttester": {
+    aminoType: "cctp/DisableAttester",
+    toAmino: chunkPV2ELBDQ_js.MsgDisableAttester.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgDisableAttester.fromAmino
+  },
+  "/circle.cctp.v1.MsgEnableAttester": {
+    aminoType: "cctp/EnableAttester",
+    toAmino: chunkPV2ELBDQ_js.MsgEnableAttester.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgEnableAttester.fromAmino
+  },
+  "/circle.cctp.v1.MsgLinkTokenPair": {
+    aminoType: "cctp/LinkTokenPair",
+    toAmino: chunkPV2ELBDQ_js.MsgLinkTokenPair.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgLinkTokenPair.fromAmino
+  },
+  "/circle.cctp.v1.MsgPauseBurningAndMinting": {
+    aminoType: "cctp/PauseBurningAndMinting",
+    toAmino: chunkPV2ELBDQ_js.MsgPauseBurningAndMinting.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgPauseBurningAndMinting.fromAmino
+  },
+  "/circle.cctp.v1.MsgPauseSendingAndReceivingMessages": {
+    aminoType: "cctp/PauseSendingAndReceivingMessages",
+    toAmino: chunkPV2ELBDQ_js.MsgPauseSendingAndReceivingMessages.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgPauseSendingAndReceivingMessages.fromAmino
+  },
+  "/circle.cctp.v1.MsgReceiveMessage": {
+    aminoType: "cctp/ReceiveMessage",
+    toAmino: chunkPV2ELBDQ_js.MsgReceiveMessage.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgReceiveMessage.fromAmino
+  },
+  "/circle.cctp.v1.MsgRemoveRemoteTokenMessenger": {
+    aminoType: "cctp/RemoveRemoteTokenMessenger",
+    toAmino: chunkPV2ELBDQ_js.MsgRemoveRemoteTokenMessenger.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgRemoveRemoteTokenMessenger.fromAmino
+  },
+  "/circle.cctp.v1.MsgReplaceDepositForBurn": {
+    aminoType: "cctp/ReplaceDepositForBurn",
+    toAmino: chunkPV2ELBDQ_js.MsgReplaceDepositForBurn.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgReplaceDepositForBurn.fromAmino
+  },
+  "/circle.cctp.v1.MsgReplaceMessage": {
+    aminoType: "cctp/ReplaceMessage",
+    toAmino: chunkPV2ELBDQ_js.MsgReplaceMessage.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgReplaceMessage.fromAmino
+  },
+  "/circle.cctp.v1.MsgSendMessage": {
+    aminoType: "cctp/SendMessage",
+    toAmino: chunkPV2ELBDQ_js.MsgSendMessage.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgSendMessage.fromAmino
+  },
+  "/circle.cctp.v1.MsgSendMessageWithCaller": {
+    aminoType: "cctp/SendMessageWithCaller",
+    toAmino: chunkPV2ELBDQ_js.MsgSendMessageWithCaller.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgSendMessageWithCaller.fromAmino
+  },
+  "/circle.cctp.v1.MsgUnlinkTokenPair": {
+    aminoType: "cctp/UnlinkTokenPair",
+    toAmino: chunkPV2ELBDQ_js.MsgUnlinkTokenPair.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgUnlinkTokenPair.fromAmino
+  },
+  "/circle.cctp.v1.MsgUnpauseBurningAndMinting": {
+    aminoType: "cctp/UnpauseBurningAndMinting",
+    toAmino: chunkPV2ELBDQ_js.MsgUnpauseBurningAndMinting.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgUnpauseBurningAndMinting.fromAmino
+  },
+  "/circle.cctp.v1.MsgUnpauseSendingAndReceivingMessages": {
+    aminoType: "cctp/UnpauseSendingAndReceivingMessages",
+    toAmino: chunkPV2ELBDQ_js.MsgUnpauseSendingAndReceivingMessages.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgUnpauseSendingAndReceivingMessages.fromAmino
+  },
+  "/circle.cctp.v1.MsgUpdateOwner": {
+    aminoType: "cctp/UpdateOwner",
+    toAmino: chunkPV2ELBDQ_js.MsgUpdateOwner.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgUpdateOwner.fromAmino
+  },
+  "/circle.cctp.v1.MsgUpdateAttesterManager": {
+    aminoType: "cctp/UpdateAttesterManager",
+    toAmino: chunkPV2ELBDQ_js.MsgUpdateAttesterManager.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgUpdateAttesterManager.fromAmino
+  },
+  "/circle.cctp.v1.MsgUpdateTokenController": {
+    aminoType: "cctp/UpdateTokenController",
+    toAmino: chunkPV2ELBDQ_js.MsgUpdateTokenController.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgUpdateTokenController.fromAmino
+  },
+  "/circle.cctp.v1.MsgUpdatePauser": {
+    aminoType: "cctp/UpdatePauser",
+    toAmino: chunkPV2ELBDQ_js.MsgUpdatePauser.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgUpdatePauser.fromAmino
+  },
+  "/circle.cctp.v1.MsgUpdateMaxMessageBodySize": {
+    aminoType: "cctp/UpdateMaxMessageBodySize",
+    toAmino: chunkPV2ELBDQ_js.MsgUpdateMaxMessageBodySize.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgUpdateMaxMessageBodySize.fromAmino
+  },
+  "/circle.cctp.v1.MsgSetMaxBurnAmountPerMessage": {
+    aminoType: "cctp/SetMaxBurnAmountPerMessage",
+    toAmino: chunkPV2ELBDQ_js.MsgSetMaxBurnAmountPerMessage.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgSetMaxBurnAmountPerMessage.fromAmino
+  },
+  "/circle.cctp.v1.MsgUpdateSignatureThreshold": {
+    aminoType: "cctp/UpdateSignatureThreshold",
+    toAmino: chunkPV2ELBDQ_js.MsgUpdateSignatureThreshold.toAmino,
+    fromAmino: chunkPV2ELBDQ_js.MsgUpdateSignatureThreshold.fromAmino
+  }
+};
+
+// src/codegen/circle/client.ts
+var circleAminoConverters = chunk6FNC3XMI_js.__spreadValues({}, AminoConverter);
+var circleProtoRegistry = [...registry];
+
+// src/constants/abis.ts
+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/constants/constants.ts
+var DEFAULT_GAS_DENOM_OVERRIDES = {
+  "noble-1": "uusdc"
+};
+function createTransaction({
+  chainId,
+  message,
+  timeoutHeight,
+  memo = "",
+  fee = utils.DEFAULT_STD_FEE,
+  signMode = 1,
+  pubKey,
+  accountNumber,
+  sequence
+}) {
+  const signers = {
+    pubKey,
+    accountNumber,
+    sequence
+  };
+  const actualSigners = Array.isArray(signers) ? signers : [signers];
+  const [signer] = actualSigners;
+  const body = tx$2.createBody({ message, memo, timeoutHeight });
+  if (!fee.amount[0]) {
+    throw new Error("createTransaction error: unable to get fee amount");
+  }
+  const feeMessage = tx$2.createFee({
+    fee: fee.amount[0],
+    payer: fee.payer,
+    granter: fee.granter,
+    gasLimit: parseInt(fee.gas, 10)
+  });
+  const signInfo = tx$2.createSigners({
+    chainId,
+    mode: signMode,
+    signers: actualSigners
+  });
+  const authInfo = tx$2.createAuthInfo({
+    signerInfo: signInfo,
+    fee: feeMessage
+  });
+  const bodyBytes = coreProtoTs.CosmosTxV1Beta1Tx.TxBody.encode(body).finish();
+  const authInfoBytes = coreProtoTs.CosmosTxV1Beta1Tx.AuthInfo.encode(authInfo).finish();
+  const signDoc = tx$2.createSignDoc({
+    chainId,
+    bodyBytes,
+    authInfoBytes,
+    accountNumber: signer.accountNumber
+  });
+  const signDocBytes = coreProtoTs.CosmosTxV1Beta1Tx.SignDoc.encode(signDoc).finish();
+  const toSignBytes = Buffer.from(signDocBytes);
+  const toSignHash = keccak256__default.default(Buffer.from(signDocBytes));
+  const txRaw = coreProtoTs.CosmosTxV1Beta1Tx.TxRaw.create();
+  txRaw.authInfoBytes = authInfoBytes;
+  txRaw.bodyBytes = bodyBytes;
+  return {
+    txRaw,
+    signDoc,
+    signers,
+    signer,
+    signBytes: toSignBytes,
+    signHashedBytes: toSignHash,
+    bodyBytes,
+    authInfoBytes
+  };
+}
+var RequestClient = class {
+  constructor({ baseURL, apiKey }) {
+    this.httpClient = axios2__default.default.create({
+      baseURL,
+      headers: apiKey ? {
+        authorization: apiKey
+      } : void 0
+    });
+  }
+  get(path, params) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      var _a, _b;
+      try {
+        const response = yield this.httpClient.get(path, {
+          params
+        });
+        return response.data;
+      } catch (error) {
+        if (error instanceof axios2.AxiosError && ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message)) {
+          throw new Error(error.response.data.message);
+        }
+        throw error;
+      }
+    });
+  }
+  post(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* (path, data = {}) {
+      var _a, _b;
+      try {
+        const response = yield this.httpClient.post(path, data);
+        return response.data;
+      } catch (error) {
+        if (error instanceof axios2.AxiosError && ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message)) {
+          throw new Error(error.response.data.message);
+        }
+        throw error;
+      }
+    });
+  }
+};
+var SKIP_API_URL = "https://api.skip.build";
+var SkipRouter = class {
+  constructor(options = {}) {
+    var _a, _b, _c;
+    this.requestClient = new RequestClient({
+      baseURL: options.apiURL || SKIP_API_URL,
+      apiKey: options.apiKey
+    });
+    this.aminoTypes = new stargate.AminoTypes(chunk6FNC3XMI_js.__spreadValues(chunk6FNC3XMI_js.__spreadValues(chunk6FNC3XMI_js.__spreadValues(chunk6FNC3XMI_js.__spreadValues({}, stargate.createDefaultAminoConverters()), cosmwasmStargate.createWasmAminoConverters()), circleAminoConverters), (_a = options.aminoTypes) != null ? _a : {}));
+    this.registry = new protoSigning.Registry([
+      ...stargate.defaultRegistryTypes,
+      ["/cosmwasm.wasm.v1.MsgExecuteContract", tx.MsgExecuteContract],
+      ["/initia.move.v1.MsgExecute", chunkPV2ELBDQ_js.MsgExecute],
+      ["/opinit.ophost.v1.MsgInitiateTokenDeposit", chunkPV2ELBDQ_js.MsgInitiateTokenDeposit],
+      ...circleProtoRegistry,
+      ...(_b = options.registryTypes) != null ? _b : []
+    ]);
+    this.endpointOptions = (_c = options.endpointOptions) != null ? _c : {};
+    this.getCosmosSigner = options.getCosmosSigner;
+    this.getEVMSigner = options.getEVMSigner;
+    this.getSVMSigner = options.getSVMSigner;
+  }
+  assets() {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* (options = {}) {
+      const response = yield this.requestClient.get(
+        "/v2/fungible/assets",
+        chunk6AMBIQDN_js.assetsRequestToJSON(chunk6FNC3XMI_js.__spreadValues({}, options))
+      );
+      return Object.entries(response.chain_to_assets_map).reduce(
+        (acc, [chainID, { assets }]) => {
+          acc[chainID] = assets.map((asset) => chunk6AMBIQDN_js.assetFromJSON(asset));
+          return acc;
+        },
+        {}
+      );
+    });
+  }
+  assetsFromSource(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const response = yield this.requestClient.post(
+        "/v2/fungible/assets_from_source",
+        chunk6AMBIQDN_js.assetsFromSourceRequestToJSON(chunk6FNC3XMI_js.__spreadValues({}, options))
+      );
+      return Object.entries(response.dest_assets).reduce(
+        (acc, [chainID, { assets }]) => {
+          acc[chainID] = assets.map((asset) => chunk6AMBIQDN_js.assetFromJSON(asset));
+          return acc;
+        },
+        {}
+      );
+    });
+  }
+  assetsBetweenChains(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const response = yield this.requestClient.post(
+        "/v2/fungible/assets_between_chains",
+        chunk6AMBIQDN_js.assetsBetweenChainsRequestToJSON(options)
+      );
+      return chunk6AMBIQDN_js.assetsBetweenChainsResponseFromJSON(response).assetsBetweenChains;
+    });
+  }
+  bridges() {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const response = yield this.requestClient.get(
+        "/v2/info/bridges"
+      );
+      return chunk6AMBIQDN_js.bridgesResponseFromJSON(response).bridges;
+    });
+  }
+  chains() {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      includeEVM,
+      includeSVM,
+      onlyTestnets,
+      chainIDs
+    } = { includeEVM: false, includeSVM: false }) {
+      const response = yield this.requestClient.get("/v2/info/chains", {
+        include_evm: includeEVM,
+        include_svm: includeSVM,
+        only_testnets: onlyTestnets,
+        chain_ids: chainIDs
+      });
+      return response.chains.map((chain) => chunk6AMBIQDN_js.chainFromJSON(chain));
+    });
+  }
+  executeRoute(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      var _a;
+      const { route, userAddresses } = options;
+      let addressList = [];
+      let i = 0;
+      for (let j = 0; j < userAddresses.length; j++) {
+        if (route.requiredChainAddresses[i] !== ((_a = userAddresses[j]) == null ? void 0 : _a.chainID)) {
+          i = j;
+          continue;
+        }
+        addressList.push(userAddresses[j].address);
+        i++;
+      }
+      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) {
+        raise("executeRoute error: invalid address list");
+      }
+      const messages = yield this.messages({
+        sourceAssetDenom: route.sourceAssetDenom,
+        sourceAssetChainID: route.sourceAssetChainID,
+        destAssetDenom: route.destAssetDenom,
+        destAssetChainID: route.destAssetChainID,
+        amountIn: route.amountIn,
+        amountOut: route.estimatedAmountOut || "0",
+        addressList,
+        operations: route.operations,
+        slippageTolerancePercent: options.slippageTolerancePercent || "1"
+      });
+      yield this.executeTxs(chunk6FNC3XMI_js.__spreadProps(chunk6FNC3XMI_js.__spreadValues({}, options), { txs: messages.txs }));
+    });
+  }
+  executeTxs(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      var _a;
+      const {
+        txs,
+        userAddresses,
+        validateGasBalance,
+        getGasPrice,
+        gasAmountMultiplier = chunkPV2ELBDQ_js.DEFAULT_GAS_MULTIPLIER,
+        getFallbackGasAmount
+      } = options;
+      let gasTokenUsed;
+      if (validateGasBalance) {
+        gasTokenUsed = yield this.validateGasBalances({
+          txs,
+          userAddresses,
+          getOfflineSigner: options.getCosmosSigner,
+          getGasPrice,
+          gasAmountMultiplier,
+          getFallbackGasAmount
+        });
+      }
+      for (let i = 0; i < txs.length; i++) {
+        const tx = txs[i];
+        if (!tx) {
+          raise(`executeRoute error: invalid message at index ${i}`);
+        }
+        let txResult;
+        if ("cosmosTx" in tx) {
+          const cosmosTx = tx.cosmosTx;
+          const currentUserAddress = (_a = userAddresses.find(
+            (x) => x.chainID === cosmosTx.chainID
+          )) == null ? void 0 : _a.address;
+          if (!currentUserAddress) {
+            raise(
+              `executeRoute error: invalid address for chain '${cosmosTx.chainID}'`
+            );
+          }
+          if (cosmosTx.chainID === "stride-1" && !gasTokenUsed) {
+            const getOfflineSigner = options.getCosmosSigner || this.getCosmosSigner;
+            if (!getOfflineSigner) {
+              throw new Error(
+                "executeRoute error: 'getCosmosSigner' is not provided or configured in skip router"
+              );
+            }
+            const signer = yield getOfflineSigner(tx.cosmosTx.chainID);
+            const endpoint = yield this.getRpcEndpointForChain(
+              tx.cosmosTx.chainID
+            );
+            const client = yield stargate.SigningStargateClient.connectWithSigner(
+              endpoint,
+              signer,
+              {
+                aminoTypes: this.aminoTypes,
+                registry: this.registry,
+                accountParser: chunkJRIEAGIQ_js.accountParser
+              }
+            );
+            gasTokenUsed = yield this.validateCosmosGasBalance({
+              chainID: cosmosTx.chainID,
+              messages: cosmosTx.msgs,
+              signerAddress: currentUserAddress,
+              getGasPrice,
+              gasAmountMultiplier,
+              getFallbackGasAmount,
+              client
+            });
+          }
+          const txResponse = yield this.executeCosmosMessage({
+            messages: cosmosTx.msgs,
+            chainID: cosmosTx.chainID,
+            getCosmosSigner: options.getCosmosSigner,
+            getGasPrice,
+            gasAmountMultiplier,
+            signerAddress: currentUserAddress,
+            getFallbackGasAmount,
+            gasTokenUsed
+          });
+          txResult = {
+            chainID: cosmosTx.chainID,
+            txHash: txResponse.transactionHash
+          };
+        } else if ("evmTx" in tx) {
+          const txResponse = yield this.executeEvmMsg(tx, options);
+          txResult = {
+            chainID: tx.evmTx.chainID,
+            txHash: txResponse.transactionHash
+          };
+        } else if ("svmTx" in tx) {
+          const { svmTx } = tx;
+          const getSVMSigner = options.getSVMSigner || this.getSVMSigner;
+          if (!getSVMSigner) {
+            throw new Error(
+              "executeRoute error: 'getSVMSigner' is not provided or configured in skip router"
+            );
+          }
+          const svmSigner = yield getSVMSigner();
+          const txReceipt = yield this.executeSVMTransaction({
+            signer: svmSigner,
+            message: svmTx
+          });
+          txResult = {
+            chainID: svmTx.chainID,
+            txHash: txReceipt
+          };
+        } else {
+          raise(`executeRoute error: invalid message type`);
+        }
+        if (options.onTransactionBroadcast) {
+          yield options.onTransactionBroadcast(chunk6FNC3XMI_js.__spreadValues({}, txResult));
+        }
+        const txStatusResponse = yield this.waitForTransaction(chunk6FNC3XMI_js.__spreadProps(chunk6FNC3XMI_js.__spreadValues({}, txResult), {
+          onTransactionTracked: options.onTransactionTracked
+        }));
+        if (options.onTransactionCompleted) {
+          yield options.onTransactionCompleted(
+            txResult.chainID,
+            txResult.txHash,
+            txStatusResponse
+          );
+        }
+      }
+    });
+  }
+  executeEvmMsg(message, options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const { evmTx } = message;
+      const getEVMSigner = options.getEVMSigner || this.getEVMSigner;
+      if (!getEVMSigner) {
+        throw new Error("Unable to get EVM signer");
+      }
+      const evmSigner = yield getEVMSigner(evmTx.chainID);
+      return yield this.executeEVMTransaction({
+        message: evmTx,
+        signer: evmSigner
+      });
+    });
+  }
+  executeCosmosMessage(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const {
+        signerAddress,
+        getCosmosSigner,
+        chainID,
+        messages,
+        getGasPrice,
+        gasAmountMultiplier,
+        getFallbackGasAmount,
+        gasTokenUsed
+      } = options;
+      const getOfflineSigner = this.getCosmosSigner || getCosmosSigner || raise(
+        "executeRoute error: 'getCosmosSigner' is not provided or configured in skip router"
+      );
+      const signer = yield getOfflineSigner(chainID);
+      const accounts = yield signer.getAccounts();
+      const accountFromSigner = accounts.find(
+        (account) => account.address === signerAddress
+      );
+      if (!accountFromSigner) {
+        throw new Error(
+          "executeMultiChainMessage error: failed to retrieve account from signer"
+        );
+      }
+      const endpoint = yield this.getRpcEndpointForChain(chainID);
+      const stargateClient = yield stargate.SigningStargateClient.connectWithSigner(
+        endpoint,
+        signer,
+        {
+          aminoTypes: this.aminoTypes,
+          registry: this.registry,
+          accountParser: chunkJRIEAGIQ_js.accountParser
+        }
+      );
+      const fee = yield this.estimateGasForMessage({
+        stargateClient,
+        chainID,
+        signerAddress,
+        gasAmountMultiplier,
+        getGasPrice,
+        messages,
+        getFallbackGasAmount
+      });
+      if (gasTokenUsed) {
+        const _fee = fee.amount.find((x) => x.denom === gasTokenUsed.denom);
+        if (_fee) {
+          fee.amount = [_fee];
+        }
+      }
+      if (fee.amount.length > 1) {
+        fee.amount = [fee.amount[0]];
+      }
+      const { accountNumber, sequence } = yield this.getAccountNumberAndSequence(
+        signerAddress,
+        chainID
+      );
+      let rawTx;
+      if (protoSigning.isOfflineDirectSigner(signer)) {
+        rawTx = yield this.signCosmosMessageDirect({
+          signerAddress,
+          signer,
+          chainID,
+          cosmosMsgs: messages,
+          fee,
+          signerData: {
+            accountNumber,
+            sequence,
+            chainId: chainID
+          }
+        });
+      } else {
+        rawTx = yield this.signCosmosMessageAmino({
+          signerAddress,
+          signer,
+          chainID,
+          cosmosMsgs: messages,
+          fee,
+          signerData: {
+            accountNumber,
+            sequence,
+            chainId: chainID
+          }
+        });
+      }
+      const txBytes = tx$1.TxRaw.encode(rawTx).finish();
+      const tx = yield stargateClient.broadcastTx(txBytes);
+      return tx;
+    });
+  }
+  estimateGasForMessage(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      stargateClient,
+      chainID,
+      signerAddress,
+      gasAmountMultiplier,
+      getGasPrice,
+      messages,
+      encodedMsgs,
+      getFallbackGasAmount
+    }) {
+      var _a;
+      const estimatedGasAmount = yield (() => chunk6FNC3XMI_js.__async(this, null, function* () {
+        try {
+          const estimatedGas = yield chunkPV2ELBDQ_js.getCosmosGasAmountForMessage(
+            stargateClient,
+            signerAddress,
+            chainID,
+            messages,
+            encodedMsgs,
+            gasAmountMultiplier
+          );
+          return estimatedGas;
+        } catch (error) {
+          if (getFallbackGasAmount) {
+            const fallbackGasAmount = yield getFallbackGasAmount(
+              chainID,
+              "cosmos"
+            );
+            if (!fallbackGasAmount) {
+              raise(
+                `executeRoute error: unable to estimate gas for message(s) ${messages || encodedMsgs}`
+              );
+            }
+            return String(fallbackGasAmount);
+          }
+          raise(
+            `executeRoute error: unable to estimate gas for message(s) ${messages || encodedMsgs}`
+          );
+        }
+      }))();
+      const gasPrice = (getGasPrice ? yield getGasPrice(chainID, "cosmos") : yield this.getRecommendedGasPrice(chainID)) || raise(
+        `executeRoute error: unable to get gas prices for chain '${chainID}'`
+      );
+      const fee = stargate.calculateFee(
+        Math.ceil(parseFloat(estimatedGasAmount)),
+        gasPrice
+      );
+      if (chainID === "stride-1") {
+        const chains4 = yield this.chains();
+        const tiaOnStride = (_a = chains4.find((x) => x.chainID === chainID)) == null ? void 0 : _a.feeAssets.find(
+          (item) => item.denom.toLowerCase() === "ibc/BF3B4F53F3694B66E13C23107C84B6485BD2B96296BB7EC680EA77BBA75B4801".toLowerCase()
+        );
+        if (tiaOnStride && tiaOnStride.gasPrice) {
+          let price = tiaOnStride.gasPrice.average;
+          if (price === "") {
+            price = tiaOnStride.gasPrice.high;
+          }
+          if (price === "") {
+            price = tiaOnStride.gasPrice.low;
+          }
+          const tiaOnStrideGasPrice = new stargate.GasPrice(
+            math.Decimal.fromUserInput(price, 18),
+            tiaOnStride.denom
+          );
+          const tiaOnStrideFee = stargate.calculateFee(
+            Math.ceil(parseFloat(estimatedGasAmount)),
+            tiaOnStrideGasPrice
+          );
+          if (tiaOnStrideFee.amount[0]) {
+            fee.amount.push(tiaOnStrideFee.amount[0]);
+          }
+        }
+      }
+      if (!fee) {
+        raise(
+          `executeRoute error: unable to get fee for message(s) ${messages || encodedMsgs}`
+        );
+      }
+      return fee;
+    });
+  }
+  executeEVMTransaction(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      message,
+      signer
+    }) {
+      if (!signer.account) {
+        throw new Error(
+          "executeEVMTransaction error: failed to retrieve account from signer"
+        );
+      }
+      const extendedSigner = signer.extend(viem.publicActions);
+      for (const requiredApproval of message.requiredERC20Approvals) {
+        const allowance = yield extendedSigner.readContract({
+          address: requiredApproval.tokenContract,
+          abi: erc20ABI,
+          functionName: "allowance",
+          args: [
+            signer.account.address,
+            requiredApproval.spender
+          ]
+        });
+        if (allowance > BigInt(requiredApproval.amount)) {
+          continue;
+        }
+        const txHash2 = yield extendedSigner.writeContract({
+          account: signer.account,
+          address: requiredApproval.tokenContract,
+          abi: erc20ABI,
+          functionName: "approve",
+          args: [requiredApproval.spender, viem.maxUint256],
+          chain: signer.chain
+        });
+        const receipt2 = yield extendedSigner.waitForTransactionReceipt({
+          hash: txHash2
+        });
+        if (receipt2.status === "reverted") {
+          throw new Error(
+            `executeEVMTransaction error: evm tx reverted for hash ${receipt2.transactionHash}`
+          );
+        }
+      }
+      const txHash = yield extendedSigner.sendTransaction({
+        account: signer.account,
+        to: message.to,
+        data: `0x${message.data}`,
+        chain: signer.chain,
+        value: message.value === "" ? void 0 : BigInt(message.value)
+      });
+      const receipt = yield extendedSigner.waitForTransactionReceipt({
+        hash: txHash
+      });
+      return receipt;
+    });
+  }
+  executeSVMTransaction(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      signer,
+      message
+    }) {
+      var _a;
+      const _tx = Buffer.from(message.tx, "base64");
+      const transaction = web3_js.Transaction.from(_tx);
+      const endpoint = yield this.getRpcEndpointForChain(message.chainID);
+      const connection = new web3_js.Connection(endpoint);
+      let signature;
+      if ("signTransaction" in signer) {
+        const tx = yield signer.signTransaction(transaction);
+        const serializedTx = tx.serialize();
+        yield this.submitTransaction({
+          chainID: message.chainID,
+          tx: Buffer.from(serializedTx).toString("base64")
+        });
+        const sig = yield connection.sendRawTransaction(serializedTx, {
+          preflightCommitment: "confirmed",
+          maxRetries: 5
+        });
+        signature = sig;
+      }
+      if (!signature) {
+        throw new Error("executeSVMTransaction error: signature not found");
+      }
+      let getStatusCount = 0;
+      let errorCount = 0;
+      while (true) {
+        try {
+          const result = yield connection.getSignatureStatus(signature, {
+            searchTransactionHistory: true
+          });
+          if (((_a = result == null ? void 0 : result.value) == null ? void 0 : _a.confirmationStatus) === "confirmed") {
+            return signature;
+          } else if (getStatusCount > 12) {
+            yield wait(3e3);
+            throw new Error(
+              `executeSVMTransaction error: waiting finalized status timed out for ${signature}`
+            );
+          }
+          getStatusCount++;
+          yield wait(3e3);
+        } catch (error) {
+          errorCount++;
+          if (errorCount > 12) {
+            throw error;
+          }
+        }
+      }
+    });
+  }
+  signCosmosMessageDirect(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const {
+        signer,
+        signerAddress,
+        chainID,
+        cosmosMsgs,
+        fee,
+        signerData: { accountNumber, sequence, chainId }
+      } = options;
+      if (chainID.includes("evmos")) {
+        return this.signCosmosMessageDirectEvmos(
+          signerAddress,
+          signer,
+          cosmosMsgs,
+          fee,
+          { accountNumber, sequence, chainId }
+        );
+      }
+      if (chainID.includes("injective")) {
+        return this.signCosmosMessageDirectInjective(
+          signerAddress,
+          signer,
+          cosmosMsgs,
+          fee,
+          { accountNumber, sequence, chainId }
+        );
+      }
+      const accounts = yield 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) => chunkPV2ELBDQ_js.getEncodeObjectFromCosmosMessage(cosmosMsg)
+      );
+      const txBodyEncodeObject = {
+        typeUrl: "/cosmos.tx.v1beta1.TxBody",
+        value: {
+          messages
+        }
+      };
+      const txBodyBytes = this.registry.encode(txBodyEncodeObject);
+      const gasLimit = math.Int53.fromString(fee.gas).toNumber();
+      const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainID);
+      const authInfoBytes = protoSigning.makeAuthInfoBytes(
+        [{ pubkey: pubkeyAny, sequence }],
+        fee.amount,
+        gasLimit,
+        fee.granter,
+        fee.payer
+      );
+      const signDoc = protoSigning.makeSignDoc(
+        txBodyBytes,
+        authInfoBytes,
+        chainId,
+        accountNumber
+      );
+      const { signature, signed } = yield signer.signDirect(
+        signerAddress,
+        signDoc
+      );
+      return tx$1.TxRaw.fromPartial({
+        bodyBytes: signed.bodyBytes,
+        authInfoBytes: signed.authInfoBytes,
+        signatures: [encoding.fromBase64(signature.signature)]
+      });
+    });
+  }
+  // TODO: This is previously existing code, just moved to a new function.
+  // Using signCosmosMessageDirectEvmos on evmos DOES currently fail.
+  // I need to investigate what exactly is even different about this and hopefully remove it all together.
+  signCosmosMessageDirectEvmos(_0, _1, _2, _3, _4) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* (signerAddress, signer, cosmosMsgs, fee, { accountNumber, sequence, chainId }) {
+      const accounts = yield signer.getAccounts();
+      const accountFromSigner = accounts.find(
+        (account) => account.address === signerAddress
+      );
+      if (!accountFromSigner) {
+        throw new Error(
+          "signCosmosMessageDirectEvmos: failed to retrieve account from signer"
+        );
+      }
+      const messages = cosmosMsgs.map(
+        (cosmosMsg) => chunkPV2ELBDQ_js.getEncodeObjectFromCosmosMessageInjective(cosmosMsg)
+      );
+      const pk = Buffer.from(accountFromSigner.pubkey).toString("base64");
+      const { signDoc } = createTransaction({
+        pubKey: pk,
+        chainId,
+        message: messages,
+        sequence,
+        accountNumber,
+        timeoutHeight: 0,
+        fee
+      });
+      const directSignResponse = yield signer.signDirect(
+        signerAddress,
+        // @ts-expect-error TODO: Fix this
+        signDoc
+      );
+      return tx$1.TxRaw.fromPartial({
+        bodyBytes: directSignResponse.signed.bodyBytes,
+        authInfoBytes: directSignResponse.signed.authInfoBytes,
+        signatures: [encoding.fromBase64(directSignResponse.signature.signature)]
+      });
+    });
+  }
+  // TODO: This is previously existing code, just moved to a new function.
+  // Using signCosmosMessageDirectInjective on injective DOES currently fail.
+  // I need to investigate what exactly is even different about this and hopefully remove it all together.
+  signCosmosMessageDirectInjective(_0, _1, _2, _3, _4) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* (signerAddress, signer, cosmosMsgs, fee, { accountNumber, sequence, chainId }) {
+      const accounts = yield signer.getAccounts();
+      const accountFromSigner = accounts.find(
+        (account) => account.address === signerAddress
+      );
+      if (!accountFromSigner) {
+        throw new Error(
+          "signCosmosMessageDirectInjective: failed to retrieve account from signer"
+        );
+      }
+      const restEndpoint = yield this.getRestEndpointForChain(chainId);
+      const chainRestTendermintApi = new rest.ChainRestTendermintApi(restEndpoint);
+      const latestBlock = yield chainRestTendermintApi.fetchLatestBlock();
+      const latestHeight = latestBlock.header.height;
+      const timeoutHeight = new utils.BigNumberInBase(latestHeight).plus(
+        utils.DEFAULT_BLOCK_TIMEOUT_HEIGHT
+      );
+      const pk = Buffer.from(accountFromSigner.pubkey).toString("base64");
+      const messages = cosmosMsgs.map(
+        (cosmosMsg) => chunkPV2ELBDQ_js.getEncodeObjectFromCosmosMessageInjective(cosmosMsg)
+      );
+      const { signDoc } = createTransaction({
+        pubKey: pk,
+        chainId,
+        message: messages,
+        sequence,
+        accountNumber,
+        timeoutHeight: timeoutHeight.toNumber(),
+        fee
+      });
+      const directSignResponse = yield signer.signDirect(
+        signerAddress,
+        // @ts-expect-error TODO: Fix this
+        signDoc
+      );
+      return tx$1.TxRaw.fromPartial({
+        bodyBytes: directSignResponse.signed.bodyBytes,
+        authInfoBytes: directSignResponse.signed.authInfoBytes,
+        signatures: [encoding.fromBase64(directSignResponse.signature.signature)]
+      });
+    });
+  }
+  signCosmosMessageAmino(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const {
+        signer,
+        signerAddress,
+        chainID,
+        cosmosMsgs,
+        fee,
+        signerData: { accountNumber, sequence, chainId }
+      } = options;
+      const accounts = yield 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) => chunkPV2ELBDQ_js.getEncodeObjectFromCosmosMessage(cosmosMsg)
+      );
+      const aminoMsgTransferIndex = messages.findIndex(
+        (x) => x.typeUrl === "/ibc.applications.transfer.v1.MsgTransfer"
+      );
+      if (aminoMsgTransferIndex !== -1) {
+        const endpoint = yield this.getRpcEndpointForChain(chainID);
+        const client = yield stargate.StargateClient.connect(endpoint, {
+          accountParser: chunkJRIEAGIQ_js.accountParser
+        });
+        const currentHeight = yield client.getHeight();
+        messages[aminoMsgTransferIndex].value.timeoutHeight = {
+          revisionHeight: currentHeight + 100,
+          revisionNumber: currentHeight + 100
+        };
+        messages[aminoMsgTransferIndex].value.timeoutTimestamp = 0;
+      }
+      const signMode = signing.SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+      const msgs = messages.map((msg) => this.aminoTypes.toAmino(msg));
+      const signDoc = amino.makeSignDoc(
+        msgs,
+        fee,
+        chainId,
+        "",
+        accountNumber,
+        sequence
+      );
+      const { signature, signed } = yield signer.signAmino(
+        signerAddress,
+        signDoc
+      );
+      const signedTxBody = {
+        messages: signed.msgs.map((msg) => this.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 = this.registry.encode(signedTxBodyEncodeObject);
+      const signedGasLimit = math.Int53.fromString(signed.fee.gas).toNumber();
+      const signedSequence = math.Int53.fromString(signed.sequence).toNumber();
+      const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainID);
+      const signedAuthInfoBytes = protoSigning.makeAuthInfoBytes(
+        [{ pubkey: pubkeyAny, sequence: signedSequence }],
+        signed.fee.amount,
+        signedGasLimit,
+        signed.fee.granter,
+        signed.fee.payer,
+        signMode
+      );
+      return tx$1.TxRaw.fromPartial({
+        bodyBytes: signedTxBodyBytes,
+        authInfoBytes: signedAuthInfoBytes,
+        signatures: [encoding.fromBase64(signature.signature)]
+      });
+    });
+  }
+  messages(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const response = yield this.requestClient.post("/v2/fungible/msgs", chunk6FNC3XMI_js.__spreadProps(chunk6FNC3XMI_js.__spreadValues({}, chunk6AMBIQDN_js.msgsRequestToJSON(options)), {
+        slippage_tolerance_percent: options.slippageTolerancePercent || "0"
+      }));
+      return chunk6AMBIQDN_js.messageResponseFromJSON(response);
+    });
+  }
+  route(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const response = yield this.requestClient.post("/v2/fungible/route", chunk6FNC3XMI_js.__spreadProps(chunk6FNC3XMI_js.__spreadValues({}, chunk6AMBIQDN_js.routeRequestToJSON(options)), {
+        cumulative_affiliate_fee_bps: options.cumulativeAffiliateFeeBPS || "0"
+      }));
+      return chunk6AMBIQDN_js.routeResponseFromJSON(response);
+    });
+  }
+  msgsDirect(options) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const response = yield this.requestClient.post("/v2/fungible/msgs_direct", chunk6FNC3XMI_js.__spreadValues({}, chunk6AMBIQDN_js.msgsDirectRequestToJSON(options)));
+      return {
+        msgs: response.msgs.map((msg) => chunk6AMBIQDN_js.msgFromJSON(msg)),
+        txs: response.txs.map((tx) => chunk6AMBIQDN_js.txFromJSON(tx)),
+        route: chunk6AMBIQDN_js.routeResponseFromJSON(response.route)
+      };
+    });
+  }
+  recommendAssets(request) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const options = chunk6AMBIQDN_js.recommendAssetsRequestToJSON({
+        requests: Array.isArray(request) ? request : [request]
+      });
+      const response = yield this.requestClient.post(
+        "/v2/fungible/recommend_assets",
+        options
+      );
+      return chunk6AMBIQDN_js.recommendAssetsResponseFromJSON(response).recommendationEntries;
+    });
+  }
+  ibcOriginAssets(assets) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const response = yield this.requestClient.post(
+        "/v2/fungible/ibc_origin_assets",
+        chunk6AMBIQDN_js.originAssetsRequestToJSON({
+          assets
+        })
+      );
+      return chunk6AMBIQDN_js.originAssetsResponseFromJSON(response).originAssets;
+    });
+  }
+  submitTransaction(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      chainID,
+      tx
+    }) {
+      const response = yield this.requestClient.post("/v2/tx/submit", {
+        chain_id: chainID,
+        tx
+      });
+      return chunk6AMBIQDN_js.submitTxResponseFromJSON(response);
+    });
+  }
+  trackTransaction(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      chainID,
+      txHash,
+      options
+    }) {
+      var _a, _b, _c, _d, _e, _f;
+      const maxRetries = (_b = (_a = options == null ? void 0 : options.retry) == null ? void 0 : _a.maxRetries) != null ? _b : 5;
+      const retryInterval = (_d = (_c = options == null ? void 0 : options.retry) == null ? void 0 : _c.retryInterval) != null ? _d : 1e3;
+      const backoffMultiplier = (_f = (_e = options == null ? void 0 : options.retry) == null ? void 0 : _e.backoffMultiplier) != null ? _f : 2;
+      let retries = 0;
+      let lastError;
+      while (retries < maxRetries) {
+        try {
+          const response = yield this.requestClient.post("/v2/tx/track", {
+            chain_id: chainID,
+            tx_hash: txHash
+          });
+          return chunk6AMBIQDN_js.trackTxResponseFromJSON(response);
+        } catch (error) {
+          lastError = error;
+          retries++;
+          yield wait(retryInterval * Math.pow(backoffMultiplier, retries - 1));
+        }
+      }
+      throw lastError;
+    });
+  }
+  transactionStatus(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      chainID,
+      txHash,
+      options
+    }) {
+      var _a, _b, _c, _d, _e, _f;
+      const maxRetries = (_b = (_a = options == null ? void 0 : options.retry) == null ? void 0 : _a.maxRetries) != null ? _b : 5;
+      const retryInterval = (_d = (_c = options == null ? void 0 : options.retry) == null ? void 0 : _c.retryInterval) != null ? _d : 1e3;
+      const backoffMultiplier = (_f = (_e = options == null ? void 0 : options.retry) == null ? void 0 : _e.backoffMultiplier) != null ? _f : 2;
+      let retries = 0;
+      let lastError;
+      while (retries < maxRetries) {
+        try {
+          const response = yield this.requestClient.get("/v2/tx/status", {
+            chain_id: chainID,
+            tx_hash: txHash
+          });
+          return chunk6AMBIQDN_js.txStatusResponseFromJSON(response);
+        } catch (error) {
+          lastError = error;
+          retries++;
+          yield wait(retryInterval * Math.pow(backoffMultiplier, retries - 1));
+        }
+      }
+      throw lastError;
+    });
+  }
+  waitForTransaction(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      chainID,
+      txHash,
+      onTransactionTracked
+    }) {
+      const { explorerLink } = yield this.trackTransaction({
+        chainID,
+        txHash,
+        options: {
+          retry: {
+            backoffMultiplier: 2.5
+          }
+        }
+      });
+      if (onTransactionTracked) {
+        yield onTransactionTracked({ txHash, chainID, explorerLink });
+      }
+      while (true) {
+        const txStatusResponse = yield this.transactionStatus({
+          chainID,
+          txHash
+        });
+        if (txStatusResponse.status === "STATE_COMPLETED") {
+          return txStatusResponse;
+        }
+        yield wait(1e3);
+      }
+    });
+  }
+  venues(onlyTestnets) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const response = yield this.requestClient.get("/v2/fungible/venues", {
+        only_testnets: onlyTestnets
+      });
+      return response.venues.map((venue) => chunk6AMBIQDN_js.swapVenueFromJSON(venue));
+    });
+  }
+  getCosmsosGasAmountForMessage(client, signerAddress, chainID, cosmosMessages) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      return chunkPV2ELBDQ_js.getCosmosGasAmountForMessage(
+        client,
+        signerAddress,
+        chainID,
+        cosmosMessages
+      );
+    });
+  }
+  getAccountNumberAndSequence(address, chainID) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      if (chainID.includes("dymension")) {
+        return this.getAccountNumberAndSequenceFromDymension(address, chainID);
+      }
+      const endpoint = yield this.getRpcEndpointForChain(chainID);
+      const client = yield stargate.StargateClient.connect(endpoint, {
+        accountParser: chunkJRIEAGIQ_js.accountParser
+      });
+      const account = yield client.getAccount(address);
+      if (!account) {
+        throw new Error(
+          "getAccountNumberAndSequence: failed to retrieve account"
+        );
+      }
+      client.disconnect();
+      return {
+        accountNumber: account.accountNumber,
+        sequence: account.sequence
+      };
+    });
+  }
+  getAccountNumberAndSequenceFromDymension(address, chainID) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const endpoint = yield this.getRestEndpointForChain(chainID);
+      const response = yield axios2__default.default.get(
+        `${endpoint}/cosmos/auth/v1beta1/accounts/${address}`
+      );
+      let sequence = 0;
+      let accountNumber = 0;
+      if (response.data.account.base_account) {
+        sequence = response.data.account.base_account.sequence;
+        accountNumber = response.data.account.base_account.account_number;
+      } else {
+        sequence = response.data.account.sequence;
+        accountNumber = response.data.account.account_number;
+      }
+      return {
+        accountNumber,
+        sequence
+      };
+    });
+  }
+  getAccountNumberAndSequenceFromEvmos(address, chainID) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const endpoint = yield this.getRestEndpointForChain(chainID);
+      const response = yield axios2__default.default.get(
+        `${endpoint}/cosmos/auth/v1beta1/accounts/${address}`
+      );
+      const accountNumber = response.data.account.base_account.account_number;
+      const sequence = response.data.account.base_account.sequence;
+      return {
+        accountNumber,
+        sequence
+      };
+    });
+  }
+  getAccountNumberAndSequenceInjective(address, chainID) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const endpoint = yield this.getRestEndpointForChain(chainID);
+      const chainRestAuthApi = new rest.ChainRestAuthApi(endpoint);
+      const accountDetailsResponse = yield chainRestAuthApi.fetchAccount(address);
+      return {
+        accountNumber: parseInt(
+          accountDetailsResponse.account.base_account.account_number
+        ),
+        sequence: parseInt(accountDetailsResponse.account.base_account.sequence)
+      };
+    });
+  }
+  getRpcEndpointForChain(chainID) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      var _a, _b, _c;
+      if (this.endpointOptions.getRpcEndpointForChain) {
+        return this.endpointOptions.getRpcEndpointForChain(chainID);
+      }
+      if (this.endpointOptions.endpoints && this.endpointOptions.endpoints[chainID]) {
+        const endpointOptions = this.endpointOptions.endpoints[chainID];
+        if (endpointOptions == null ? void 0 : endpointOptions.rpc) {
+          return endpointOptions.rpc;
+        }
+      }
+      let chain;
+      chain = chains3().find((chain2) => chain2.chain_id === chainID);
+      if (!chain) {
+        chain = initiaChains().find((chain2) => chain2.chain_id === chainID);
+      }
+      if (!chain) {
+        throw new Error(
+          `getRpcEndpointForChain: failed to find chain id '${chainID}' in registry`
+        );
+      }
+      const endpoint = (_c = (_b = (_a = chain.apis) == null ? void 0 : _a.rpc) == null ? void 0 : _b[0]) == null ? void 0 : _c.address;
+      if (!endpoint) {
+        throw new Error(
+          `getRpcEndpointForChain error: failed to find RPC endpoint for chain '${chainID}'`
+        );
+      }
+      return endpoint;
+    });
+  }
+  getRestEndpointForChain(chainID) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      var _a, _b, _c;
+      if (this.endpointOptions.getRestEndpointForChain) {
+        return this.endpointOptions.getRestEndpointForChain(chainID);
+      }
+      if (this.endpointOptions.endpoints && this.endpointOptions.endpoints[chainID]) {
+        const endpointOptions = this.endpointOptions.endpoints[chainID];
+        if (endpointOptions == null ? void 0 : endpointOptions.rest) {
+          return endpointOptions.rest;
+        }
+      }
+      let chain;
+      chain = chains3().find((chain2) => chain2.chain_id === chainID);
+      if (!chain) {
+        chain = initiaChains().find((chain2) => chain2.chain_id === chainID);
+      }
+      if (!chain) {
+        throw new Error(
+          `getRestEndpointForChain error: failed to find chain id '${chainID}' in registry`
+        );
+      }
+      const endpoint = (_c = (_b = (_a = chain.apis) == null ? void 0 : _a.rest) == null ? void 0 : _b[0]) == null ? void 0 : _c.address;
+      if (!endpoint) {
+        throw new Error(
+          `getRestEndpointForChain error: failed to find REST endpoint for chain '${chainID}'`
+        );
+      }
+      return endpoint;
+    });
+  }
+  getCosmosFeeForMessage(_0, _1) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* (chainID, msgs, gasAmountMultiplier = chunkPV2ELBDQ_js.DEFAULT_GAS_MULTIPLIER, signer, gasPrice) {
+      var _a, _b;
+      gasPrice || (gasPrice = yield this.getRecommendedGasPrice(chainID));
+      if (!gasPrice) {
+        throw new Error(
+          `getFeeForMessage error: Unable to get gas price for chain: ${chainID}`
+        );
+      }
+      signer || (signer = yield (_a = this.getCosmosSigner) == null ? void 0 : _a.call(this, chainID));
+      if (!signer) {
+        throw new Error(
+          "getFeeForMessage error: signer is not provided or 'getCosmosSigner' is not configured in skip router"
+        );
+      }
+      const accounts = yield signer.getAccounts();
+      const signerAddress = ((_b = accounts[0]) == null ? void 0 : _b.address) || raise(
+        `getFeeForMessage error: unable to resolve account address from signer`
+      );
+      const endpoint = yield this.getRpcEndpointForChain(chainID);
+      const client = yield stargate.SigningStargateClient.connectWithSigner(
+        endpoint,
+        signer,
+        {
+          aminoTypes: this.aminoTypes,
+          registry: this.registry,
+          accountParser: chunkJRIEAGIQ_js.accountParser
+        }
+      );
+      const gasNeeded = yield chunkPV2ELBDQ_js.getCosmosGasAmountForMessage(
+        client,
+        signerAddress,
+        chainID,
+        msgs,
+        void 0,
+        gasAmountMultiplier
+      );
+      const fee = stargate.calculateFee(Math.ceil(parseFloat(gasNeeded)), gasPrice);
+      if (!fee) {
+        throw new Error("getFeeForMessage error: unable to get fee for message");
+      }
+      return fee;
+    });
+  }
+  getRecommendedGasPrice(chainID) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      const feeInfo = yield this.getFeeInfoForChain(chainID);
+      if (!feeInfo || !feeInfo.gasPrice) {
+        return void 0;
+      }
+      let price = feeInfo.gasPrice.average;
+      if (price === "") {
+        price = feeInfo.gasPrice.high;
+      }
+      if (price === "") {
+        price = feeInfo.gasPrice.low;
+      }
+      return new stargate.GasPrice(math.Decimal.fromUserInput(price, 18), feeInfo.denom);
+    });
+  }
+  getFeeInfoForChain(chainID) {
+    return chunk6FNC3XMI_js.__async(this, null, function* () {
+      var _a, _b;
+      const skipChains = [
+        ...yield this.chains({}),
+        ...yield this.chains({ onlyTestnets: true })
+      ];
+      const skipChain = skipChains.find((chain2) => chain2.chainID === chainID);
+      if (!skipChain) {
+        return void 0;
+      }
+      const defaultGasToken = yield this.getDefaultGasTokenForChain(chainID);
+      if (!defaultGasToken && !skipChain.feeAssets) {
+        return void 0;
+      }
+      const skipFeeInfo = defaultGasToken ? skipChain.feeAssets.find((skipFee) => skipFee.denom === defaultGasToken) : skipChain.feeAssets[0];
+      if (!skipFeeInfo && ((_b = (_a = skipChain.feeAssets) == null ? void 0 : _a[0]) == null ? void 0 : _b.gasPrice) !== null) {
+        return skipChain.feeAssets[0];
+      }
+      if (skipFeeInfo && skipFeeInfo.gasPrice !== null) {
+        return skipFeeInfo;
+      }
+      let chain;
+      chain = chains3().find((chain2) => chain2.chain_id === chainID);
+      if (!chain) {
+        chain = initiaChains().find((chain2) => chain2.chain_id === chainID);
+      }
+      if (!chain) {
+        return void 0;
+      }
+      if (!chain.fees) {
+        return void 0;
+      }
+      const registryFeeInfo = chain.fees.fee_tokens.find(
+        (feeToken) => feeToken.denom === defaultGasToken
+      );
+      if (!registryFeeInfo) {
+        return void 0;
+      }
+      return {
+        denom: registryFeeInfo.denom,
+        gasPrice: {
+          low: registryFeeInfo.low_gas_price ? `${registryFeeInfo.low_gas_price}` : "",
+          average: registryFeeInfo.average_gas_price ? `${registryFeeInfo.average_gas_price}` : "",
+          high: registryFeeInfo.high_gas_price ? `${registryFeeInfo.high_gas_price}` : ""
+        }
+      };
+    });
+  }
+  getDefaultGasTokenForChain(chainID) {
+    var _a;
+    const gasDenom = DEFAULT_GAS_DENOM_OVERRIDES[chainID];
+    if (gasDenom) {
+      return gasDenom;
+    }
+    let chain;
+    chain = chains3().find((chain2) => chain2.chain_id === chainID);
+    if (!chain) {
+      chain = initiaChains().find((chain2) => chain2.chain_id === chainID);
+    }
+    if (!chain) {
+      return void 0;
+    }
+    if (!chain.fees) {
+      return void 0;
+    }
+    const stakingTokens = this.getStakingTokensForChain(chainID);
+    if (stakingTokens && stakingTokens.length > 0) {
+      const feeAsset = chain.fees.fee_tokens.find(
+        (feeToken) => {
+          var _a2;
+          return feeToken.denom === ((_a2 = stakingTokens[0]) == null ? void 0 : _a2.denom);
+        }
+      );
+      if (feeAsset) {
+        return feeAsset.denom;
+      }
+    }
+    const nonIBCAsset = chain.fees.fee_tokens.find(
+      (token) => !token.denom.startsWith("ibc/") && !token.denom.startsWith("l2/")
+    );
+    if (nonIBCAsset) {
+      return nonIBCAsset.denom;
+    }
+    const nonL2Asset = chain.fees.fee_tokens.find(
+      (token) => !token.denom.startsWith("l2/")
+    );
+    if (nonL2Asset) {
+      return nonL2Asset.denom;
+    }
+    return (_a = chain.fees.fee_tokens[0]) == null ? void 0 : _a.denom;
+  }
+  getStakingTokensForChain(chainID) {
+    let chain;
+    chain = chains3().find((chain2) => chain2.chain_id === chainID);
+    if (!chain) {
+      chain = initiaChains().find((chain2) => chain2.chain_id === chainID);
+    }
+    if (!chain) {
+      throw new Error(
+        `getStakingTokensForChain error: failed to find chain id '${chainID}' in registry`
+      );
+    }
+    if (!chain.staking) {
+      return void 0;
+    }
+    return chain.staking.staking_tokens;
+  }
+  validateGasBalances(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      txs,
+      userAddresses,
+      getOfflineSigner,
+      getGasPrice,
+      gasAmountMultiplier,
+      getFallbackGasAmount
+    }) {
+      var _a;
+      for (let i = 0; i < txs.length; i++) {
+        const tx = txs[i];
+        if (!tx) {
+          raise(`validateGasBalances error: invalid tx at index ${i}`);
+        }
+        if ("cosmosTx" in tx) {
+          const msgs = tx.cosmosTx.msgs;
+          if (!msgs) {
+            raise(`validateGasBalances error: invalid msgs ${msgs}`);
+          }
+          getOfflineSigner = getOfflineSigner || this.getCosmosSigner;
+          if (!getOfflineSigner) {
+            throw new Error(
+              "executeRoute error: 'getCosmosSigner' is not provided or configured in skip router"
+            );
+          }
+          const signer = yield getOfflineSigner(tx.cosmosTx.chainID);
+          const endpoint = yield this.getRpcEndpointForChain(tx.cosmosTx.chainID);
+          const client = yield stargate.SigningStargateClient.connectWithSigner(
+            endpoint,
+            signer,
+            {
+              aminoTypes: this.aminoTypes,
+              registry: this.registry,
+              accountParser: chunkJRIEAGIQ_js.accountParser
+            }
+          );
+          const currentAddress = ((_a = userAddresses.find(
+            (address) => address.chainID === tx.cosmosTx.chainID
+          )) == null ? void 0 : _a.address) || raise(
+            `validateGasBalance error: invalid address for chain '${tx.cosmosTx.chainID}'`
+          );
+          return yield this.validateCosmosGasBalance({
+            client,
+            signerAddress: currentAddress,
+            chainID: tx.cosmosTx.chainID,
+            messages: msgs,
+            getGasPrice,
+            gasAmountMultiplier,
+            getFallbackGasAmount
+          });
+        }
+      }
+    });
+  }
+  validateCosmosGasBalance(_0) {
+    return chunk6FNC3XMI_js.__async(this, arguments, function* ({
+      chainID,
+      client,
+      signerAddress,
+      messages,
+      getGasPrice,
+      gasAmountMultiplier,
+      getFallbackGasAmount
+    }) {
+      var _a, _b;
+      const fee = yield this.estimateGasForMessage({
+        stargateClient: client,
+        chainID,
+        signerAddress,
+        gasAmountMultiplier,
+        getGasPrice,
+        messages,
+        getFallbackGasAmount
+      });
+      if (!fee.amount[0]) {
+        throw new Error(
+          `validateCosmosGasBalance error: unable to get fee amount`
+        );
+      }
+      const mainnetAssets = yield this.assets();
+      const testnetAssets = yield this.assets({ onlyTestnets: true });
+      const assets = chunk6FNC3XMI_js.__spreadValues(chunk6FNC3XMI_js.__spreadValues({}, mainnetAssets), testnetAssets);
+      const assetByChainID = assets[chainID];
+      const result = yield Promise.all(
+        fee.amount.map((amount) => chunk6FNC3XMI_js.__async(this, null, function* () {
+          const asset = assetByChainID == null ? void 0 : assetByChainID.find(
+            (asset2) => asset2.denom.toLowerCase() === amount.denom.toLowerCase()
+          );
+          if (!asset || !asset.decimals) {
+            return {
+              errMessage: `${amount.denom} is not found in assets for ${chainID}.`,
+              amount
+            };
+          }
+          const balance = yield client.getBalance(signerAddress, amount.denom);
+          if (parseInt(balance.amount) < parseInt(amount.amount)) {
+            const formattedBalance = Number(balance.amount) / Math.pow(10, asset.decimals);
+            const formattedAmount = Number(amount.amount) / Math.pow(10, asset.decimals);
+            return {
+              errMessage: `Insufficient fee token to initiate transfer on ${chainID}. Need ${formattedAmount} ${asset.recommendedSymbol || amount.denom}, but only have ${formattedBalance} ${asset.recommendedSymbol || amount.denom}.`,
+              amount
+            };
+          }
+          return {
+            errMessage: null,
+            amount
+          };
+        }))
+      );
+      const successful = result.find((res) => res.errMessage === null);
+      if (!successful) {
+        if (result.length > 1) {
+          throw new Error(
+            ((_a = result[0]) == null ? void 0 : _a.errMessage) || `Insufficient fee token to initiate transfer on ${chainID}.`
+          );
+        }
+        throw new Error(
+          ((_b = result[0]) == null ? void 0 : _b.errMessage) || `Insufficient fee token to initiate transfer on ${chainID}.`
+        );
+      }
+      return successful.amount;
+    });
+  }
+};
+function raise(message, options) {
+  throw new Error(message, options);
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+Object.defineProperty(exports, "DEFAULT_GAS_MULTIPLIER", {
+  enumerable: true,
+  get: function () { return chunkPV2ELBDQ_js.DEFAULT_GAS_MULTIPLIER; }
+});
+Object.defineProperty(exports, "getCosmosGasAmountForMessage", {
+  enumerable: true,
+  get: function () { return chunkPV2ELBDQ_js.getCosmosGasAmountForMessage; }
+});
+Object.defineProperty(exports, "getEncodeObjectFromCosmosMessage", {
+  enumerable: true,
+  get: function () { return chunkPV2ELBDQ_js.getEncodeObjectFromCosmosMessage; }
+});
+Object.defineProperty(exports, "getEncodeObjectFromCosmosMessageInjective", {
+  enumerable: true,
+  get: function () { return chunkPV2ELBDQ_js.getEncodeObjectFromCosmosMessageInjective; }
+});
+Object.defineProperty(exports, "affiliateFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.affiliateFromJSON; }
+});
+Object.defineProperty(exports, "affiliateToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.affiliateToJSON; }
+});
+Object.defineProperty(exports, "assetBetweenChainsFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetBetweenChainsFromJSON; }
+});
+Object.defineProperty(exports, "assetBetweenChainsToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetBetweenChainsToJSON; }
+});
+Object.defineProperty(exports, "assetFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetFromJSON; }
+});
+Object.defineProperty(exports, "assetOrErrorFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetOrErrorFromJSON; }
+});
+Object.defineProperty(exports, "assetOrErrorToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetOrErrorToJSON; }
+});
+Object.defineProperty(exports, "assetRecommendationFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetRecommendationFromJSON; }
+});
+Object.defineProperty(exports, "assetRecommendationRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetRecommendationRequestFromJSON; }
+});
+Object.defineProperty(exports, "assetRecommendationRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetRecommendationRequestToJSON; }
+});
+Object.defineProperty(exports, "assetRecommendationToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetRecommendationToJSON; }
+});
+Object.defineProperty(exports, "assetToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetToJSON; }
+});
+Object.defineProperty(exports, "assetsBetweenChainsRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetsBetweenChainsRequestFromJSON; }
+});
+Object.defineProperty(exports, "assetsBetweenChainsRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetsBetweenChainsRequestToJSON; }
+});
+Object.defineProperty(exports, "assetsBetweenChainsResponseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetsBetweenChainsResponseFromJSON; }
+});
+Object.defineProperty(exports, "assetsFromSourceRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetsFromSourceRequestFromJSON; }
+});
+Object.defineProperty(exports, "assetsFromSourceRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetsFromSourceRequestToJSON; }
+});
+Object.defineProperty(exports, "assetsRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetsRequestFromJSON; }
+});
+Object.defineProperty(exports, "assetsRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.assetsRequestToJSON; }
+});
+Object.defineProperty(exports, "axelarTransferFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.axelarTransferFromJSON; }
+});
+Object.defineProperty(exports, "axelarTransferInfoFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.axelarTransferInfoFromJSON; }
+});
+Object.defineProperty(exports, "axelarTransferInfoToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.axelarTransferInfoToJSON; }
+});
+Object.defineProperty(exports, "axelarTransferToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.axelarTransferToJSON; }
+});
+Object.defineProperty(exports, "axelarTransferTransactionsFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.axelarTransferTransactionsFromJSON; }
+});
+Object.defineProperty(exports, "axelarTransferTransactionsToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.axelarTransferTransactionsToJSON; }
+});
+Object.defineProperty(exports, "bankSendFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.bankSendFromJSON; }
+});
+Object.defineProperty(exports, "bankSendToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.bankSendToJSON; }
+});
+Object.defineProperty(exports, "bridgeFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.bridgeFromJSON; }
+});
+Object.defineProperty(exports, "bridgeToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.bridgeToJSON; }
+});
+Object.defineProperty(exports, "bridgesResponseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.bridgesResponseFromJSON; }
+});
+Object.defineProperty(exports, "bridgesResponseToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.bridgesResponseToJSON; }
+});
+Object.defineProperty(exports, "cctpTransferFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cctpTransferFromJSON; }
+});
+Object.defineProperty(exports, "cctpTransferInfoFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cctpTransferInfoFromJSON; }
+});
+Object.defineProperty(exports, "cctpTransferInfoToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cctpTransferInfoToJSON; }
+});
+Object.defineProperty(exports, "cctpTransferToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cctpTransferToJSON; }
+});
+Object.defineProperty(exports, "cctpTransferTransactionsFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cctpTransferTransactionsFromJSON; }
+});
+Object.defineProperty(exports, "cctpTransferTransactionsToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cctpTransferTransactionsToJSON; }
+});
+Object.defineProperty(exports, "chainAffiliatesFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.chainAffiliatesFromJSON; }
+});
+Object.defineProperty(exports, "chainAffiliatesToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.chainAffiliatesToJSON; }
+});
+Object.defineProperty(exports, "chainFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.chainFromJSON; }
+});
+Object.defineProperty(exports, "chainIDsToAffiliatesMapFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.chainIDsToAffiliatesMapFromJSON; }
+});
+Object.defineProperty(exports, "chainIDsToAffiliatesMapToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.chainIDsToAffiliatesMapToJSON; }
+});
+Object.defineProperty(exports, "chainToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.chainToJSON; }
+});
+Object.defineProperty(exports, "chainTransactionFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.chainTransactionFromJSON; }
+});
+Object.defineProperty(exports, "chainTransactionToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.chainTransactionToJSON; }
+});
+Object.defineProperty(exports, "contractCallWithTokenTransactionsFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.contractCallWithTokenTransactionsFromJSON; }
+});
+Object.defineProperty(exports, "contractCallWithTokenTransactionsToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.contractCallWithTokenTransactionsToJSON; }
+});
+Object.defineProperty(exports, "cosmWasmContractMsgFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cosmWasmContractMsgFromJSON; }
+});
+Object.defineProperty(exports, "cosmWasmContractMsgToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cosmWasmContractMsgToJSON; }
+});
+Object.defineProperty(exports, "cosmosMsgFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cosmosMsgFromJSON; }
+});
+Object.defineProperty(exports, "cosmosMsgToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cosmosMsgToJSON; }
+});
+Object.defineProperty(exports, "cosmosTxFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cosmosTxFromJSON; }
+});
+Object.defineProperty(exports, "cosmosTxToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.cosmosTxToJSON; }
+});
+Object.defineProperty(exports, "denomWithChainIDFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.denomWithChainIDFromJSON; }
+});
+Object.defineProperty(exports, "denomWithChainIDToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.denomWithChainIDToJSON; }
+});
+Object.defineProperty(exports, "erc20ApprovalFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.erc20ApprovalFromJSON; }
+});
+Object.defineProperty(exports, "erc20ApprovalToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.erc20ApprovalToJSON; }
+});
+Object.defineProperty(exports, "estimatedFeeFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.estimatedFeeFromJSON; }
+});
+Object.defineProperty(exports, "estimatedFeeToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.estimatedFeeToJSON; }
+});
+Object.defineProperty(exports, "evmSwapFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.evmSwapFromJSON; }
+});
+Object.defineProperty(exports, "evmSwapToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.evmSwapToJSON; }
+});
+Object.defineProperty(exports, "evmTxFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.evmTxFromJSON; }
+});
+Object.defineProperty(exports, "evmTxToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.evmTxToJSON; }
+});
+Object.defineProperty(exports, "feeAssetFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.feeAssetFromJSON; }
+});
+Object.defineProperty(exports, "feeAssetToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.feeAssetToJSON; }
+});
+Object.defineProperty(exports, "hyperlaneTransferFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.hyperlaneTransferFromJSON; }
+});
+Object.defineProperty(exports, "hyperlaneTransferInfoFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.hyperlaneTransferInfoFromJSON; }
+});
+Object.defineProperty(exports, "hyperlaneTransferInfoToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.hyperlaneTransferInfoToJSON; }
+});
+Object.defineProperty(exports, "hyperlaneTransferToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.hyperlaneTransferToJSON; }
+});
+Object.defineProperty(exports, "hyperlaneTransferTransactionsFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.hyperlaneTransferTransactionsFromJSON; }
+});
+Object.defineProperty(exports, "hyperlaneTransferTransactionsToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.hyperlaneTransferTransactionsToJSON; }
+});
+Object.defineProperty(exports, "ibcAddressFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.ibcAddressFromJSON; }
+});
+Object.defineProperty(exports, "ibcAddressToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.ibcAddressToJSON; }
+});
+Object.defineProperty(exports, "ibcCapabilitiesFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.ibcCapabilitiesFromJSON; }
+});
+Object.defineProperty(exports, "ibcCapabilitiesToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.ibcCapabilitiesToJSON; }
+});
+Object.defineProperty(exports, "messageResponseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.messageResponseFromJSON; }
+});
+Object.defineProperty(exports, "msgFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.msgFromJSON; }
+});
+Object.defineProperty(exports, "msgToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.msgToJSON; }
+});
+Object.defineProperty(exports, "msgsDirectRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.msgsDirectRequestFromJSON; }
+});
+Object.defineProperty(exports, "msgsDirectRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.msgsDirectRequestToJSON; }
+});
+Object.defineProperty(exports, "msgsRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.msgsRequestFromJSON; }
+});
+Object.defineProperty(exports, "msgsRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.msgsRequestToJSON; }
+});
+Object.defineProperty(exports, "multiChainMsgFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.multiChainMsgFromJSON; }
+});
+Object.defineProperty(exports, "multiChainMsgToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.multiChainMsgToJSON; }
+});
+Object.defineProperty(exports, "nextBlockingTransferFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.nextBlockingTransferFromJSON; }
+});
+Object.defineProperty(exports, "nextBlockingTransferToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.nextBlockingTransferToJSON; }
+});
+Object.defineProperty(exports, "opInitTransferFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.opInitTransferFromJSON; }
+});
+Object.defineProperty(exports, "opInitTransferInfoFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.opInitTransferInfoFromJSON; }
+});
+Object.defineProperty(exports, "opInitTransferInfoToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.opInitTransferInfoToJSON; }
+});
+Object.defineProperty(exports, "opInitTransferToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.opInitTransferToJSON; }
+});
+Object.defineProperty(exports, "opInitTransferTransactionsFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.opInitTransferTransactionsFromJSON; }
+});
+Object.defineProperty(exports, "opInitTransferTransactionsToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.opInitTransferTransactionsToJSON; }
+});
+Object.defineProperty(exports, "operationFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.operationFromJSON; }
+});
+Object.defineProperty(exports, "operationToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.operationToJSON; }
+});
+Object.defineProperty(exports, "originAssetsRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.originAssetsRequestFromJSON; }
+});
+Object.defineProperty(exports, "originAssetsRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.originAssetsRequestToJSON; }
+});
+Object.defineProperty(exports, "originAssetsResponseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.originAssetsResponseFromJSON; }
+});
+Object.defineProperty(exports, "originAssetsResponseToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.originAssetsResponseToJSON; }
+});
+Object.defineProperty(exports, "packetFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.packetFromJSON; }
+});
+Object.defineProperty(exports, "packetToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.packetToJSON; }
+});
+Object.defineProperty(exports, "postHandlerFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.postHandlerFromJSON; }
+});
+Object.defineProperty(exports, "postHandlerToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.postHandlerToJSON; }
+});
+Object.defineProperty(exports, "recommendAssetsRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.recommendAssetsRequestFromJSON; }
+});
+Object.defineProperty(exports, "recommendAssetsRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.recommendAssetsRequestToJSON; }
+});
+Object.defineProperty(exports, "recommendAssetsResponseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.recommendAssetsResponseFromJSON; }
+});
+Object.defineProperty(exports, "recommendAssetsResponseToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.recommendAssetsResponseToJSON; }
+});
+Object.defineProperty(exports, "recommendationEntryFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.recommendationEntryFromJSON; }
+});
+Object.defineProperty(exports, "recommendationEntryToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.recommendationEntryToJSON; }
+});
+Object.defineProperty(exports, "routeRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.routeRequestFromJSON; }
+});
+Object.defineProperty(exports, "routeRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.routeRequestToJSON; }
+});
+Object.defineProperty(exports, "routeResponseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.routeResponseFromJSON; }
+});
+Object.defineProperty(exports, "routeResponseToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.routeResponseToJSON; }
+});
+Object.defineProperty(exports, "sendTokenTransactionsFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.sendTokenTransactionsFromJSON; }
+});
+Object.defineProperty(exports, "sendTokenTransactionsToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.sendTokenTransactionsToJSON; }
+});
+Object.defineProperty(exports, "smartSwapExactCoinInFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.smartSwapExactCoinInFromJSON; }
+});
+Object.defineProperty(exports, "smartSwapExactCoinInToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.smartSwapExactCoinInToJSON; }
+});
+Object.defineProperty(exports, "smartSwapOptionsFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.smartSwapOptionsFromJSON; }
+});
+Object.defineProperty(exports, "smartSwapOptionsToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.smartSwapOptionsToJSON; }
+});
+Object.defineProperty(exports, "submitTxRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.submitTxRequestFromJSON; }
+});
+Object.defineProperty(exports, "submitTxRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.submitTxRequestToJSON; }
+});
+Object.defineProperty(exports, "submitTxResponseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.submitTxResponseFromJSON; }
+});
+Object.defineProperty(exports, "submitTxResponseToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.submitTxResponseToJSON; }
+});
+Object.defineProperty(exports, "svmTxFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.svmTxFromJSON; }
+});
+Object.defineProperty(exports, "svmTxToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.svmTxToJSON; }
+});
+Object.defineProperty(exports, "swapExactCoinInFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapExactCoinInFromJSON; }
+});
+Object.defineProperty(exports, "swapExactCoinInToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapExactCoinInToJSON; }
+});
+Object.defineProperty(exports, "swapExactCoinOutFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapExactCoinOutFromJSON; }
+});
+Object.defineProperty(exports, "swapExactCoinOutToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapExactCoinOutToJSON; }
+});
+Object.defineProperty(exports, "swapFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapFromJSON; }
+});
+Object.defineProperty(exports, "swapOperationFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapOperationFromJSON; }
+});
+Object.defineProperty(exports, "swapOperationToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapOperationToJSON; }
+});
+Object.defineProperty(exports, "swapRouteFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapRouteFromJSON; }
+});
+Object.defineProperty(exports, "swapRouteToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapRouteToJSON; }
+});
+Object.defineProperty(exports, "swapToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapToJSON; }
+});
+Object.defineProperty(exports, "swapVenueFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapVenueFromJSON; }
+});
+Object.defineProperty(exports, "swapVenueRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapVenueRequestFromJSON; }
+});
+Object.defineProperty(exports, "swapVenueRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapVenueRequestToJSON; }
+});
+Object.defineProperty(exports, "swapVenueToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.swapVenueToJSON; }
+});
+Object.defineProperty(exports, "trackTxRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.trackTxRequestFromJSON; }
+});
+Object.defineProperty(exports, "trackTxRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.trackTxRequestToJSON; }
+});
+Object.defineProperty(exports, "trackTxResponseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.trackTxResponseFromJSON; }
+});
+Object.defineProperty(exports, "trackTxResponseToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.trackTxResponseToJSON; }
+});
+Object.defineProperty(exports, "transferAssetReleaseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferAssetReleaseFromJSON; }
+});
+Object.defineProperty(exports, "transferAssetReleaseToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferAssetReleaseToJSON; }
+});
+Object.defineProperty(exports, "transferEventFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferEventFromJSON; }
+});
+Object.defineProperty(exports, "transferEventToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferEventToJSON; }
+});
+Object.defineProperty(exports, "transferFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferFromJSON; }
+});
+Object.defineProperty(exports, "transferInfoFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferInfoFromJSON; }
+});
+Object.defineProperty(exports, "transferInfoToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferInfoToJSON; }
+});
+Object.defineProperty(exports, "transferStatusFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferStatusFromJSON; }
+});
+Object.defineProperty(exports, "transferStatusToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferStatusToJSON; }
+});
+Object.defineProperty(exports, "transferToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.transferToJSON; }
+});
+Object.defineProperty(exports, "txFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.txFromJSON; }
+});
+Object.defineProperty(exports, "txStatusRequestFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.txStatusRequestFromJSON; }
+});
+Object.defineProperty(exports, "txStatusRequestToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.txStatusRequestToJSON; }
+});
+Object.defineProperty(exports, "txStatusResponseFromJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.txStatusResponseFromJSON; }
+});
+Object.defineProperty(exports, "txStatusResponseToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.txStatusResponseToJSON; }
+});
+Object.defineProperty(exports, "txToJSON", {
+  enumerable: true,
+  get: function () { return chunk6AMBIQDN_js.txToJSON; }
+});
+exports.SKIP_API_URL = SKIP_API_URL;
+exports.SkipRouter = SkipRouter;