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

package/dist/{chunk-RE2QZJWE.js → chunk-PRQ2NHRZ.js}

@@ -1,13 +1,11 @@
-'use strict';
-
-var chunkASPVKNJ7_js = require('./chunk-ASPVKNJ7.js');
+import { api } from './chunk-W6TBGBV3.js';
 
 // src/api/postIbcOriginAssets.ts
-var ibcOriginAssets = chunkASPVKNJ7_js.api({
+var ibcOriginAssets = api({
   methodName: "getOriginAssets",
   method: "post",
   path: "/v2/fungible/ibc_origin_assets",
   transformResponse: (response) => response.originAssets
 });
 
-exports.ibcOriginAssets = ibcOriginAssets;
+export { ibcOriginAssets };

package/dist/chunk-RDRDFJQE.js

@@ -0,0 +1,10 @@
+import { api } from './chunk-W6TBGBV3.js';
+
+// src/api/postSubmitTransaction.ts
+var submitTransaction = api({
+  methodName: "submitTransactionV2",
+  method: "post",
+  path: "/v2/tx/submit"
+});
+
+export { submitTransaction };

package/dist/chunk-RMP3HM5N.js

@@ -0,0 +1,14 @@
+import { transformAssetsMap } from './chunk-BRMONS6A.js';
+import { api } from './chunk-W6TBGBV3.js';
+
+// src/api/postAssetsFromSource.ts
+var assetsFromSource = api({
+  methodName: "getAssetsFromSource",
+  method: "post",
+  path: "/v2/fungible/assets_from_source",
+  transformResponse(response) {
+    return transformAssetsMap(response.destAssets);
+  }
+});
+
+export { assetsFromSource };

package/dist/{chunk-X2YPYBVN.js → chunk-SONZJVQM.js}

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

package/dist/chunk-SWYON2RG.js

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