@skip-go/client 1.0.1-alpha-1 → 1.0.1

package/dist/chunk-SWYON2RG.js

@@ -1,7 +1,10 @@
+'use strict';
+
 // src/constants/constants.ts
 var DEFAULT_GAS_DENOM_OVERRIDES = {
   "noble-1": "uusdc"
 };
 var GAS_STATION_CHAIN_IDS = ["bbn-test-5", "bbn-1"];
 
-export { DEFAULT_GAS_DENOM_OVERRIDES, GAS_STATION_CHAIN_IDS };
+exports.DEFAULT_GAS_DENOM_OVERRIDES = DEFAULT_GAS_DENOM_OVERRIDES;
+exports.GAS_STATION_CHAIN_IDS = GAS_STATION_CHAIN_IDS;

package/dist/chunk-VQ5SIQWU.js

@@ -1,3 +1,5 @@
+'use strict';
+
 // ../../node_modules/bignumber.js/bignumber.mjs
 var isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
 var mathceil = Math.ceil;
@@ -1341,4 +1343,4 @@ function toFixedPoint(str, e, z) {
 }
 var BigNumber = clone();
 
-export { BigNumber };
+exports.BigNumber = BigNumber;

package/dist/chunk-X2E2TKVR.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
+
+// src/api/postMessagesDirect.ts
+var messagesDirect = chunkASPVKNJ7_js.api({
+  methodName: "getMsgsDirectV2",
+  method: "post",
+  path: "/v2/fungible/msgs_direct"
+});
+
+exports.messagesDirect = messagesDirect;

package/dist/{chunk-3N7XVGLX.js → chunk-X2YPYBVN.js}

@@ -1,14 +1,18 @@
-import { chains, findFirstWorkingEndpoint } from './chunk-JTIHU43D.js';
-import { ClientState } from './chunk-BRMONS6A.js';
-import { accountFromAny, SigningStargateClient } from '@cosmjs/stargate';
-import { assertDefinedAndNotNull } from '@cosmjs/utils';
-import { BinaryWriter, BinaryReader } from 'cosmjs-types/binary';
-import { BaseAccount } from 'cosmjs-types/cosmos/auth/v1beta1/auth';
-import { Coin } from 'cosmjs-types/cosmos/base/v1beta1/coin';
-import { decodePubkey } from '@cosmjs/proto-signing';
-import { accountEthParser } from '@injectivelabs/sdk-ts';
-import { PubKey } from 'cosmjs-types/cosmos/crypto/secp256k1/keys';
-import { encodeSecp256k1Pubkey } from '@cosmjs/amino';
+'use strict';
+
+var chunkCG5CQQBW_js = require('./chunk-CG5CQQBW.js');
+var chunk6GJEXV5J_js = require('./chunk-6GJEXV5J.js');
+var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
+var signingstargateclient = require('@cosmjs/stargate/build/signingstargateclient');
+var stargate = require('@cosmjs/stargate');
+var utils = require('@cosmjs/utils');
+var binary = require('cosmjs-types/binary');
+var auth = require('cosmjs-types/cosmos/auth/v1beta1/auth');
+var coin = require('cosmjs-types/cosmos/base/v1beta1/coin');
+var protoSigning = require('@cosmjs/proto-signing');
+var sdkTs = require('@injectivelabs/sdk-ts');
+var keys = require('cosmjs-types/cosmos/crypto/secp256k1/keys');
+var amino = require('@cosmjs/amino');
 
 var createBaseVestingAccount = () => {
   return {
@@ -21,21 +25,21 @@ var createBaseVestingAccount = () => {
   };
 };
 var BaseVestingAccount = {
-  encode(message, writer = BinaryWriter.create()) {
+  encode(message, writer = binary.BinaryWriter.create()) {
     if (message.baseAccount !== void 0) {
-      BaseAccount.encode(
+      auth.BaseAccount.encode(
         message.baseAccount,
         writer.uint32(10).fork()
       ).ldelim();
     }
     for (const v of message.originalVesting) {
-      Coin.encode(v, writer.uint32(18).fork()).ldelim();
+      coin.Coin.encode(v, writer.uint32(18).fork()).ldelim();
     }
     for (const v of message.delegatedFree) {
-      Coin.encode(v, writer.uint32(26).fork()).ldelim();
+      coin.Coin.encode(v, writer.uint32(26).fork()).ldelim();
     }
     for (const v of message.delegatedVesting) {
-      Coin.encode(v, writer.uint32(34).fork()).ldelim();
+      coin.Coin.encode(v, writer.uint32(34).fork()).ldelim();
     }
     if (message.endTime !== BigInt(0)) {
       writer.uint32(40).int64(message.endTime);
@@ -43,23 +47,23 @@ var BaseVestingAccount = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const reader = input instanceof binary.BinaryReader ? input : new binary.BinaryReader(input);
     const end = length === void 0 ? reader.len : reader.pos + length;
     const message = createBaseVestingAccount();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.baseAccount = BaseAccount.decode(reader, reader.uint32());
+          message.baseAccount = auth.BaseAccount.decode(reader, reader.uint32());
           break;
         case 2:
-          message.originalVesting.push(Coin.decode(reader, reader.uint32()));
+          message.originalVesting.push(coin.Coin.decode(reader, reader.uint32()));
           break;
         case 3:
-          message.delegatedFree.push(Coin.decode(reader, reader.uint32()));
+          message.delegatedFree.push(coin.Coin.decode(reader, reader.uint32()));
           break;
         case 4:
-          message.delegatedVesting.push(Coin.decode(reader, reader.uint32()));
+          message.delegatedVesting.push(coin.Coin.decode(reader, reader.uint32()));
           break;
         case 5:
           message.endTime = reader.int64();
@@ -81,7 +85,7 @@ function createBasePeriod() {
   };
 }
 var Period = {
-  encode(message, writer = BinaryWriter.create()) {
+  encode(message, writer = binary.BinaryWriter.create()) {
     if (message.startTime !== BigInt(0)) {
       writer.uint32(8).int64(message.startTime);
     }
@@ -89,7 +93,7 @@ var Period = {
       writer.uint32(16).int64(message.length);
     }
     for (const v of message.amount) {
-      Coin.encode(v, writer.uint32(26).fork()).ldelim();
+      coin.Coin.encode(v, writer.uint32(26).fork()).ldelim();
     }
     if (message.actionType !== 0) {
       writer.uint32(32).int32(message.actionType);
@@ -97,7 +101,7 @@ var Period = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const reader = input instanceof binary.BinaryReader ? input : new binary.BinaryReader(input);
     const end = length === void 0 ? reader.len : reader.pos + length;
     const message = createBasePeriod();
     while (reader.pos < end) {
@@ -110,7 +114,7 @@ var Period = {
           message.length = reader.int64();
           break;
         case 3:
-          message.amount.push(Coin.decode(reader, reader.uint32()));
+          message.amount.push(coin.Coin.decode(reader, reader.uint32()));
           break;
         case 4:
           message.actionType = reader.int32();
@@ -132,7 +136,7 @@ function createBaseStridePeriodicVestingAccount() {
   };
 }
 var StridePeriodicVestingAccount = {
-  encode(message, writer = BinaryWriter.create()) {
+  encode(message, writer = binary.BinaryWriter.create()) {
     if (message.baseVestingAccount !== void 0) {
       BaseVestingAccount.encode(
         message.baseVestingAccount,
@@ -145,7 +149,7 @@ var StridePeriodicVestingAccount = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const reader = input instanceof binary.BinaryReader ? input : new binary.BinaryReader(input);
     const end = length === void 0 ? reader.len : reader.pos + length;
     const message = createBaseStridePeriodicVestingAccount();
     while (reader.pos < end) {
@@ -169,32 +173,33 @@ var StridePeriodicVestingAccount = {
   }
 };
 var accountParser = (acc) => {
+  var _a;
   switch (acc.typeUrl) {
     case "/stride.vesting.StridePeriodicVestingAccount": {
-      const baseAccount = StridePeriodicVestingAccount.decode(acc.value).baseVestingAccount?.baseAccount;
-      assertDefinedAndNotNull(baseAccount);
+      const baseAccount = (_a = StridePeriodicVestingAccount.decode(acc.value).baseVestingAccount) == null ? void 0 : _a.baseAccount;
+      utils.assertDefinedAndNotNull(baseAccount);
       return {
         address: baseAccount.address,
-        pubkey: baseAccount.pubKey ? decodePubkey(baseAccount.pubKey) : null,
+        pubkey: baseAccount.pubKey ? protoSigning.decodePubkey(baseAccount.pubKey) : null,
         accountNumber: Number(baseAccount.accountNumber),
         sequence: Number(baseAccount.sequence)
       };
     }
     case "/injective.types.v1beta1.EthAccount":
-      return accountEthParser(
+      return sdkTs.accountEthParser(
         acc,
         "/injective.crypto.v1beta1.ethsecp256k1.PubKey"
       );
     case "/ethermint.types.v1.EthAccount":
-      return accountEthParser(acc, "/ethermint.crypto.v1.ethsecp256k1.PubKey");
+      return sdkTs.accountEthParser(acc, "/ethermint.crypto.v1.ethsecp256k1.PubKey");
     default: {
       if (acc.typeUrl === "/cosmos.auth.v1beta1.BaseAccount") {
-        const { address, pubKey, accountNumber, sequence } = BaseAccount.decode(
+        const { address, pubKey, accountNumber, sequence } = auth.BaseAccount.decode(
           acc.value
         );
-        if (pubKey?.typeUrl === "/initia.crypto.v1beta1.ethsecp256k1.PubKey") {
-          const { key } = PubKey.decode(pubKey.value);
-          const pk = encodeSecp256k1Pubkey(key);
+        if ((pubKey == null ? void 0 : pubKey.typeUrl) === "/initia.crypto.v1beta1.ethsecp256k1.PubKey") {
+          const { key } = keys.PubKey.decode(pubKey.value);
+          const pk = amino.encodeSecp256k1Pubkey(key);
           return {
             address,
             pubkey: pk,
@@ -203,67 +208,71 @@ var accountParser = (acc) => {
           };
         }
       }
-      return accountFromAny(acc);
+      return stargate.accountFromAny(acc);
     }
   }
 };
 
 // src/private-functions/getRpcEndpointForChain.ts
-var getRpcEndpointForChain = async (chainId) => {
-  if (ClientState.endpointOptions.getRpcEndpointForChain) {
-    return ClientState.endpointOptions.getRpcEndpointForChain(chainId);
+var getRpcEndpointForChain = (chainId) => chunkASPVKNJ7_js.__async(void 0, null, function* () {
+  var _a, _b, _c, _d, _e;
+  if (chunk6GJEXV5J_js.ClientState.endpointOptions.getRpcEndpointForChain) {
+    return chunk6GJEXV5J_js.ClientState.endpointOptions.getRpcEndpointForChain(chainId);
   }
-  if (ClientState.endpointOptions.endpoints && ClientState.endpointOptions.endpoints[chainId]) {
-    const endpointOptions = ClientState.endpointOptions.endpoints[chainId];
-    if (endpointOptions?.rpc) {
+  if (chunk6GJEXV5J_js.ClientState.endpointOptions.endpoints && chunk6GJEXV5J_js.ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = chunk6GJEXV5J_js.ClientState.endpointOptions.endpoints[chainId];
+    if (endpointOptions == null ? void 0 : endpointOptions.rpc) {
       return endpointOptions.rpc;
     }
   }
   console.warn(
     "Warning: You are using unreliable public endpoints. We strongly recommend overriding them via endpointOptions for use beyond development settings."
   );
-  const chain = chains().find((chain2) => chain2.chain_id === chainId);
+  const chain = chunkCG5CQQBW_js.chains().find((chain2) => chain2.chain_id === chainId);
   if (!chain) {
     throw new Error(`getRpcEndpointForChain: failed to find chain id '${chainId}' in registry`);
   }
-  if (chain.apis?.rpc?.length === 0 || !chain.apis?.rpc) {
+  if (((_b = (_a = chain.apis) == null ? void 0 : _a.rpc) == null ? void 0 : _b.length) === 0 || !((_c = chain.apis) == null ? void 0 : _c.rpc)) {
     throw new Error(
       `getRpcEndpointForChain error: failed to find RPC endpoint for chain '${chainId}'`
     );
   }
-  const endpoints = chain.apis?.rpc?.map((api) => api.address);
-  const endpoint = await findFirstWorkingEndpoint(endpoints, "rpc");
+  const endpoints = (_e = (_d = chain.apis) == null ? void 0 : _d.rpc) == null ? void 0 : _e.map((api) => api.address);
+  const endpoint = yield chunkCG5CQQBW_js.findFirstWorkingEndpoint(endpoints, "rpc");
   if (!endpoint) {
     throw new Error(
       `getRpcEndpointForChain error: failed to find RPC endpoint for chain '${chainId}'`
     );
   }
   return endpoint;
-};
+});
 
 // src/public-functions/getSigningStargateClient.ts
-var getSigningStargateClient = async ({
+var getSigningStargateClient = (_0) => chunkASPVKNJ7_js.__async(void 0, [_0], function* ({
   chainId,
   getOfflineSigner
-}) => {
+}) {
+  var _a;
   if (!getOfflineSigner) {
     throw new Error("'getCosmosSigner' is not provided or configured in skip router");
   }
-  if (!ClientState.signingStargateClientByChainId?.[chainId]) {
-    const [signer, endpoint] = await Promise.all([
+  if (!((_a = chunk6GJEXV5J_js.ClientState.signingStargateClientByChainId) == null ? void 0 : _a[chainId])) {
+    const [signer, endpoint] = yield Promise.all([
       getOfflineSigner(chainId),
       getRpcEndpointForChain(chainId)
     ]);
-    ClientState.signingStargateClientByChainId[chainId] = await SigningStargateClient.connectWithSigner(endpoint, signer, {
-      aminoTypes: ClientState.aminoTypes,
-      registry: ClientState.registry,
+    chunk6GJEXV5J_js.ClientState.signingStargateClientByChainId[chainId] = yield signingstargateclient.SigningStargateClient.connectWithSigner(endpoint, signer, {
+      aminoTypes: chunk6GJEXV5J_js.ClientState.aminoTypes,
+      registry: chunk6GJEXV5J_js.ClientState.registry,
       accountParser
     });
   }
   return {
-    stargateClient: ClientState.signingStargateClientByChainId[chainId],
-    signer: await getOfflineSigner(chainId)
+    stargateClient: chunk6GJEXV5J_js.ClientState.signingStargateClientByChainId[chainId],
+    signer: yield getOfflineSigner(chainId)
   };
-};
+});
 
-export { accountParser, getRpcEndpointForChain, getSigningStargateClient };
+exports.accountParser = accountParser;
+exports.getRpcEndpointForChain = getRpcEndpointForChain;
+exports.getSigningStargateClient = getSigningStargateClient;

package/dist/chunk-YYNIFO2A.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
+
+// src/api/postTrackTransaction.ts
+var trackTransaction = chunkASPVKNJ7_js.pollingApi({
+  methodName: "trackTransactionV2",
+  path: "/v2/tx/track",
+  method: "post",
+  backoffMultiplier: 2.5
+});
+
+exports.trackTransaction = trackTransaction;

package/dist/{chunk-4JJWOILI.js → chunk-Z4ZKOUGH.js}

@@ -1,7 +1,9 @@
-import { api } from './chunk-W6TBGBV3.js';
+'use strict';
+
+var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
 
 // src/api/postRecommendAssets.ts
-var recommendAssets = api({
+var recommendAssets = chunkASPVKNJ7_js.api({
   methodName: "getAssetRecommendations",
   method: "post",
   path: "/v2/fungible/recommend_assets",
@@ -10,4 +12,4 @@ var recommendAssets = api({
   }
 });
 
-export { recommendAssets };
+exports.recommendAssets = recommendAssets;

package/dist/{chunk-C2EDPY6J.js → chunk-ZG23Z3WY.js}

@@ -1,10 +1,12 @@
-import { api } from './chunk-W6TBGBV3.js';
+'use strict';
+
+var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
 
 // src/api/getVenues.ts
-var venues = api({
+var venues = chunkASPVKNJ7_js.api({
   methodName: "getVenues",
   path: "/v2/fungible/venues",
   transformResponse: (response) => response.venues
 });
 
-export { venues };
+exports.venues = venues;

package/dist/client-types-CxjtffyG.d.ts

@@ -0,0 +1,60 @@
+import { OfflineAminoSigner } from '@cosmjs/amino';
+import { OfflineDirectSigner } from '@cosmjs/proto-signing';
+import { StdFee, GasPrice, SignerData } from '@cosmjs/stargate';
+import { WalletClient } from 'viem';
+import { Adapter } from '@solana/wallet-adapter-base';
+import { a2 as FeeAsset, K as ChainType, V as CosmosMsg } from './swaggerTypes-O9-gvCT1.js';
+
+/** Common Types */
+type UserAddress = {
+    chainId: string;
+    address: string;
+};
+type EndpointOptions = {
+    rpc?: string;
+    rest?: string;
+};
+type ValidateGasResult = {
+    error: null | string;
+    asset: FeeAsset | null;
+    fee: StdFee | null;
+};
+/** Signer Getters */
+type SignerGetters = {
+    getEvmSigner?: (chainId: string) => Promise<WalletClient>;
+    getCosmosSigner?: (chainId: string) => Promise<(OfflineAminoSigner & OfflineDirectSigner) | OfflineAminoSigner | OfflineDirectSigner>;
+    getSvmSigner?: () => Promise<Adapter>;
+};
+/** Gas Options */
+type GetFallbackGasAmount = (chainId: string, chainType: ChainType) => Promise<number | undefined>;
+type GetGasPrice = (chainId: string, chainType: ChainType) => Promise<GasPrice | undefined>;
+type GasOptions = {
+    /**
+     * If `getGasPrice` is undefined, or returns undefined, the router will attempt to set the recommended gas price
+     **/
+    getGasPrice?: GetGasPrice;
+    /**
+     * If `getFallbackGasAmount` is set, when router fails to simulate the gas amount, it will use the fallback gas amount
+     */
+    getFallbackGasAmount?: GetFallbackGasAmount;
+    gasAmountMultiplier?: number;
+};
+type SignCosmosMessageOptionsBase = {
+    signerAddress: string;
+    chainId: string;
+    cosmosMsgs: CosmosMsg[];
+    fee: StdFee;
+    signerData: SignerData;
+};
+type SignCosmosMessageDirectOptions = SignCosmosMessageOptionsBase & {
+    signer: OfflineDirectSigner;
+};
+type SignCosmosMessageAminoOptions = SignCosmosMessageOptionsBase & {
+    signer: OfflineAminoSigner;
+};
+type TxResult = {
+    txHash: string;
+    chainId: string;
+};
+
+export type { EndpointOptions as E, GetFallbackGasAmount as G, SignerGetters as S, TxResult as T, UserAddress as U, ValidateGasResult as V, GetGasPrice as a, GasOptions as b, SignCosmosMessageOptionsBase as c, SignCosmosMessageDirectOptions as d, SignCosmosMessageAminoOptions as e };

package/dist/executeRoute-BKvMVd1I.d.ts

@@ -0,0 +1,69 @@
+import { aT as TransferStatus, R as Erc20Approval, ap as RouteResponse, V as CosmosMsg } from './swaggerTypes-O9-gvCT1.js';
+import { A as ApiRequest } from './generateApi-DqCp36fX.js';
+import { S as SignerGetters, b as GasOptions, U as UserAddress } from './client-types-CxjtffyG.js';
+
+type CallbackStatus = "success" | "error" | "pending" | "completed";
+type TransactionCallbacks = {
+    onTransactionSigned?: (txInfo: {
+        chainId: string;
+    }) => Promise<void>;
+    onTransactionBroadcast?: (txInfo: {
+        txHash: string;
+        chainId: string;
+    }) => Promise<void>;
+    onTransactionTracked?: (txInfo: {
+        txHash: string;
+        chainId: string;
+        explorerLink: string;
+    }) => Promise<void>;
+    onTransactionCompleted?: (txInfo: {
+        chainId: string;
+        txHash: string;
+        status?: TransferStatus;
+    }) => Promise<void>;
+    onValidateGasBalance?: (value: {
+        chainId?: string;
+        txIndex?: number;
+        status: CallbackStatus;
+    }) => Promise<void>;
+    onApproveAllowance?: (value: {
+        allowance?: Erc20Approval;
+        status: CallbackStatus;
+    }) => Promise<void>;
+};
+
+/** Execute Route Options */
+type ExecuteRouteOptions = SignerGetters & GasOptions & TransactionCallbacks & Pick<ApiRequest<"getMsgsV2">, "timeoutSeconds"> & {
+    route: RouteResponse;
+    /**
+     * Addresses should be in the same order with the `chainIDs` in the `route`
+     */
+    userAddresses: UserAddress[];
+    simulate?: boolean;
+    slippageTolerancePercent?: string;
+    /**
+     * Arbitrary Tx to be executed before or after route msgs
+     */
+    beforeMsg?: CosmosMsg;
+    afterMsg?: CosmosMsg;
+    /**
+     * Set allowance amount to max if EVM transaction requires allowance approval.
+     */
+    useUnlimitedApproval?: boolean;
+    /**
+    /**
+     * If `skipApproval` is set to `true`, the router will bypass checking whether
+     * the signer has granted approval for the specified token contract on an EVM chain.
+     * This can be useful if approval has already been handled externally or there are race conditions.
+     */
+    bypassApprovalCheck?: boolean;
+    /**
+     * defaults to true
+     * If `batchSimulate` is set to `true`, it will simulate all messages in a batch before the first tx run.
+     * If `batchSimulate` is set to `false`, it will simulate each message one by one.
+     */
+    batchSimulate?: boolean;
+};
+declare const executeRoute: (options: ExecuteRouteOptions) => Promise<void>;
+
+export { type ExecuteRouteOptions as E, type TransactionCallbacks as T, executeRoute as e };

package/dist/generateApi-DqCp36fX.d.ts

@@ -0,0 +1,22 @@
+import { bc as Api } from './swaggerTypes-O9-gvCT1.js';
+
+type CamelKey<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<CamelKey<U>>}` : S;
+type Camel<T> = T extends (infer U)[] ? Camel<U>[] : T extends object ? {
+    [K in keyof T as K extends string ? CamelKey<K> : never]: Camel<T[K]>;
+} : T;
+
+type ApiInstance = InstanceType<typeof Api>;
+type FunctionKeys<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+type ValidApiMethodKeys = {
+    [K in FunctionKeys<ApiInstance>]: Awaited<ReturnType<ApiInstance[K]>> extends {
+        data: unknown;
+    } ? K : never;
+}[FunctionKeys<ApiInstance>];
+type ApiRequest<K extends ValidApiMethodKeys> = NonNullable<Camel<Parameters<ApiInstance[K]>[0]>>;
+type ApiResponse<K extends ValidApiMethodKeys> = Camel<Awaited<ReturnType<ApiInstance[K]>> extends {
+    data: infer D;
+} ? D extends object ? D : never : never>;
+
+export type { ApiRequest as A, ApiResponse as a };

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+export { A as AcknowledgementErrorDetails, a as Affiliate, bc as Api, b8 as ApiConfig, b as ApiError, c as Asset, d as AssetBetweenChains, e as AssetRecommendation, f as AutopilotAction, g as AutopilotMsg, h as AutopilotMsgWrapper, i as AxelarTransfer, j as AxelarTransferInfo, k as AxelarTransferState, l as AxelarTransferType, m as AxelarTransferWrapper, B as BalanceRequestChainEntry, D as BalanceResponseChainEntry, z as BalanceResponseDenomEntry, E as BankSend, F as BankSendWrapper, H as Bridge, I as BridgeType, C as CCTPTransfer, n as CCTPTransferInfo, p as CCTPTransferState, o as CCTPTransferTxs, q as CCTPTransferWrapper, J as Chain, L as ChainAffiliates, al as ChainTransaction, K as ChainType, ba as ContentType, M as ContractCallWithTokenError, N as ContractCallWithTokenErrorType, O as ContractCallWithTokenTxs, P as CosmWasmContractMsg, Q as CosmWasmContractMsgWrapper, b0 as CosmosModuleSupport, V as CosmosMsg, W as CosmosTx, X as CosmosTxWrapper, R as Erc20Approval, U as Error, T as ErrorDetail, aV as EurekaTransfer, aW as EurekaTransferInfo, aX as EurekaTransferWrapper, Y as EvmSwap, Z as EvmSwapWrapper, _ as EvmTx, $ as EvmTxWrapper, b3 as Fee, a2 as FeeAsset, b2 as FeeType, b6 as FullRequestParams, a4 as GRPCStatusCode, a3 as GoFastFee, G as GoFastTransfer, y as GoFastTransferInfo, w as GoFastTransferState, x as GoFastTransferTxs, bb as HttpClient, b9 as HttpResponse, a5 as HyperlaneTransfer, a6 as HyperlaneTransferInfo, a7 as HyperlaneTransferState, a8 as HyperlaneTransferTransactions, a9 as HyperlaneTransferWrapper, aa as IBCTransferInfo, b1 as IbcCapabilities, aY as LayerZeroTransfer, aZ as LayerZeroTransferInfo, aO as LayerZeroTransferState, ah as LayerZeroTransferTransactions, a_ as LayerZeroTransferWrapper, ab as Msg, ad as MultiChainMsg, ae as MultiChainMsgWrapper, aJ as OPInitTransfer, aL as OPInitTransferInfo, aN as OPInitTransferState, aM as OPInitTransferTxs, aK as OPInitTransferWrapper, af as Operation, ag as OptionalAsset, ai as Packet, aj as PacketError, ak as PacketErrorType, am as PostHandler, b4 as QueryParamsType, an as Reason, a$ as RecommendationRequest, b7 as RequestParams, b5 as ResponseFormat, ao as RoutePriceWarningType, ap as RouteResponse, aq as SendTokenError, ar as SendTokenErrorType, as as SendTokenTxs, S as SmartRelayFeeQuote, aC as SmartSwapExactCoinIn, aE as SmartSwapInWrapper, aD as SmartSwapOptions, r as StargateTransfer, u as StargateTransferInfo, s as StargateTransferState, t as StargateTransferTxs, v as StargateTransferWrapper, at as StatusError, au as StatusErrorType, a0 as SvmTx, a1 as SvmTxWrapper, av as Swap, aw as SwapExactCoinIn, ax as SwapExactCoinOut, ay as SwapInWrapper, az as SwapOperation, aA as SwapOutWrapper, aB as SwapRoute, aF as SwapVenue, aG as SwapWrapper, aH as TransactionExecutionErrorDetails, aI as TransactionState, aP as Transfer, aS as TransferAssetRelease, aQ as TransferEvent, aR as TransferState, aT as TransferStatus, aU as TransferWrapper, ac as Tx } from './swaggerTypes-O9-gvCT1.js';
+export { E as ExecuteRouteOptions, T as TransactionCallbacks, e as executeRoute } from './executeRoute-BKvMVd1I.js';
+export { E as EndpointOptions, b as GasOptions, G as GetFallbackGasAmount, a as GetGasPrice, e as SignCosmosMessageAminoOptions, d as SignCosmosMessageDirectOptions, c as SignCosmosMessageOptionsBase, S as SignerGetters, T as TxResult, U as UserAddress, V as ValidateGasResult } from './client-types-CxjtffyG.js';
+export { assets } from './api/getAssets.js';
+export { assetsBetweenChains } from './api/getAssetsBetweenChains.js';
+export { bridges } from './api/getBridges.js';
+export { chains } from './api/getChains.js';
+export { venues } from './api/getVenues.js';
+export { ibcOriginAssets } from './api/postIbcOriginAssets.js';
+export { MessagesRequest, MessagesResponse, messages } from './api/postMessages.js';
+export { messagesDirect } from './api/postMessagesDirect.js';
+export { recommendAssets } from './api/postRecommendAssets.js';
+export { assetsFromSource } from './api/postAssetsFromSource.js';
+export { BalanceRequest, BalanceResponse, balances } from './api/postBalances.js';
+export { RouteRequest, route } from './api/postRoute.js';
+export { submitTransaction } from './api/postSubmitTransaction.js';
+export { trackTransaction } from './api/postTrackTransaction.js';
+export { TxStatusResponse, transactionStatus } from './api/postTransactionStatus.js';
+export { getSigningStargateClient, getSigningStargateClientProps } from './public-functions/getSigningStargateClient.js';
+export { S as SkipClientOptions, s as setClientOptions } from './setClientOptions-DbanEIwL.js';
+export { getRecommendedGasPrice } from './public-functions/getRecommendedGasPrice.js';
+export { getFeeInfoForChain } from './public-functions/getFeeInfoForChain.js';
+export { SetApiOptionsProps, setApiOptions } from './public-functions/setApiOptions.js';
+import './generateApi-DqCp36fX.js';
+import '@cosmjs/amino';
+import '@cosmjs/proto-signing';
+import '@cosmjs/stargate';
+import 'viem';
+import '@solana/wallet-adapter-base';
+import './apiState-CdzxTxYd.js';
+import '@cosmjs/proto-signing/build/signer';
+import '@cosmjs/stargate/build/signingstargateclient';
+import '@cosmjs/stargate/build/fee';
+
+declare const GAS_STATION_CHAIN_IDS: string[];
+
+export { GAS_STATION_CHAIN_IDS };