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

package/dist/chunk-SW3SEQMJ.cjs

@@ -0,0 +1,273 @@
+'use strict';
+
+var chunk7SK3IFXJ_cjs = require('./chunk-7SK3IFXJ.cjs');
+var chunkED2OY55G_cjs = require('./chunk-ED2OY55G.cjs');
+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 {
+    // @ts-expect-error
+    baseAccount: void 0,
+    originalVesting: [],
+    delegatedFree: [],
+    delegatedVesting: [],
+    endTime: BigInt(0)
+  };
+};
+var BaseVestingAccount = {
+  encode(message, writer = binary.BinaryWriter.create()) {
+    if (message.baseAccount !== void 0) {
+      auth.BaseAccount.encode(
+        message.baseAccount,
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    for (const v of message.originalVesting) {
+      coin.Coin.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.delegatedFree) {
+      coin.Coin.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.delegatedVesting) {
+      coin.Coin.encode(v, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.endTime !== BigInt(0)) {
+      writer.uint32(40).int64(message.endTime);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    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 = auth.BaseAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.originalVesting.push(coin.Coin.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.delegatedFree.push(coin.Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.delegatedVesting.push(coin.Coin.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.endTime = reader.int64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+function createBasePeriod() {
+  return {
+    startTime: BigInt(0),
+    length: BigInt(0),
+    amount: [],
+    actionType: 0
+  };
+}
+var Period = {
+  encode(message, writer = binary.BinaryWriter.create()) {
+    if (message.startTime !== BigInt(0)) {
+      writer.uint32(8).int64(message.startTime);
+    }
+    if (message.length !== BigInt(0)) {
+      writer.uint32(16).int64(message.length);
+    }
+    for (const v of message.amount) {
+      coin.Coin.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.actionType !== 0) {
+      writer.uint32(32).int32(message.actionType);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    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) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.startTime = reader.int64();
+          break;
+        case 2:
+          message.length = reader.int64();
+          break;
+        case 3:
+          message.amount.push(coin.Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.actionType = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+function createBaseStridePeriodicVestingAccount() {
+  return {
+    //eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    //@ts-ignore
+    baseVestingAccount: void 0,
+    vestingPeriods: []
+  };
+}
+var StridePeriodicVestingAccount = {
+  encode(message, writer = binary.BinaryWriter.create()) {
+    if (message.baseVestingAccount !== void 0) {
+      BaseVestingAccount.encode(
+        message.baseVestingAccount,
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    for (const v of message.vestingPeriods) {
+      Period.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    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) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseVestingAccount = BaseVestingAccount.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 3:
+          message.vestingPeriods.push(Period.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var accountParser = (acc) => {
+  switch (acc.typeUrl) {
+    case "/stride.vesting.StridePeriodicVestingAccount": {
+      const baseAccount = StridePeriodicVestingAccount.decode(acc.value).baseVestingAccount?.baseAccount;
+      utils.assertDefinedAndNotNull(baseAccount);
+      return {
+        address: baseAccount.address,
+        pubkey: baseAccount.pubKey ? protoSigning.decodePubkey(baseAccount.pubKey) : null,
+        accountNumber: Number(baseAccount.accountNumber),
+        sequence: Number(baseAccount.sequence)
+      };
+    }
+    case "/injective.types.v1beta1.EthAccount":
+      return sdkTs.accountEthParser(
+        acc,
+        "/injective.crypto.v1beta1.ethsecp256k1.PubKey"
+      );
+    case "/ethermint.types.v1.EthAccount":
+      return sdkTs.accountEthParser(acc, "/ethermint.crypto.v1.ethsecp256k1.PubKey");
+    default: {
+      if (acc.typeUrl === "/cosmos.auth.v1beta1.BaseAccount") {
+        const { address, pubKey, accountNumber, sequence } = auth.BaseAccount.decode(
+          acc.value
+        );
+        if (pubKey?.typeUrl === "/initia.crypto.v1beta1.ethsecp256k1.PubKey") {
+          const { key } = keys.PubKey.decode(pubKey.value);
+          const pk = amino.encodeSecp256k1Pubkey(key);
+          return {
+            address,
+            pubkey: pk,
+            accountNumber: Number(accountNumber),
+            sequence: Number(sequence)
+          };
+        }
+      }
+      return stargate.accountFromAny(acc);
+    }
+  }
+};
+
+// src/private-functions/getRpcEndpointForChain.ts
+var getRpcEndpointForChain = async (chainId) => {
+  if (chunkED2OY55G_cjs.ClientState.endpointOptions.getRpcEndpointForChain) {
+    return chunkED2OY55G_cjs.ClientState.endpointOptions.getRpcEndpointForChain(chainId);
+  }
+  if (chunkED2OY55G_cjs.ClientState.endpointOptions.endpoints && chunkED2OY55G_cjs.ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = chunkED2OY55G_cjs.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 = chunk7SK3IFXJ_cjs.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) {
+    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 chunk7SK3IFXJ_cjs.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 ({
+  chainId,
+  getOfflineSigner
+}) => {
+  if (!getOfflineSigner) {
+    throw new Error("'getCosmosSigner' is not provided or configured in skip router");
+  }
+  if (!chunkED2OY55G_cjs.ClientState.signingStargateClientByChainId?.[chainId]) {
+    const [signer, endpoint] = await Promise.all([
+      getOfflineSigner(chainId),
+      getRpcEndpointForChain(chainId)
+    ]);
+    chunkED2OY55G_cjs.ClientState.signingStargateClientByChainId[chainId] = await stargate.SigningStargateClient.connectWithSigner(endpoint, signer, {
+      aminoTypes: chunkED2OY55G_cjs.ClientState.aminoTypes,
+      registry: chunkED2OY55G_cjs.ClientState.registry,
+      accountParser
+    });
+  }
+  return {
+    stargateClient: chunkED2OY55G_cjs.ClientState.signingStargateClientByChainId[chainId],
+    signer: await getOfflineSigner(chainId)
+  };
+};
+
+exports.accountParser = accountParser;
+exports.getRpcEndpointForChain = getRpcEndpointForChain;
+exports.getSigningStargateClient = getSigningStargateClient;

package/dist/{chunk-2ETF4N4H.mjs → chunk-TW77BXMT.js}

@@ -1,4 +1,4 @@
-import { ApiState, createRequestClient } from './chunk-RXWDHQLG.mjs';
+import { ApiState, createRequestClient } from './chunk-W6TBGBV3.js';
 
 // src/public-functions/setApiOptions.ts
 var setApiOptions = (options = {}) => {
@@ -14,9 +14,8 @@ var setApiOptions = (options = {}) => {
   return ApiState.clientInitialized;
 };
 function validateChainIdsToAffiliates(chainIdsToAffiliates) {
-  var _a;
   const affiliatesArray = Object.values(chainIdsToAffiliates).map((chain) => chain.affiliates).filter((a) => a !== void 0);
-  const firstAffiliateBasisPointsFee = (_a = affiliatesArray[0]) == null ? void 0 : _a.reduce((acc, affiliate) => {
+  const firstAffiliateBasisPointsFee = affiliatesArray[0]?.reduce((acc, affiliate) => {
     if (!affiliate.basisPointsFee) {
       throw new Error("basisPointFee must exist in each affiliate");
     }
@@ -30,7 +29,7 @@ function validateChainIdsToAffiliates(chainIdsToAffiliates) {
       if (!affiliate2.address) {
         throw new Error("address to receive fee must exist in each affiliate");
       }
-      return acc + parseInt(affiliate2 == null ? void 0 : affiliate2.basisPointsFee, 10);
+      return acc + parseInt(affiliate2?.basisPointsFee, 10);
     }, 0);
     return totalBasisPointsFee === firstAffiliateBasisPointsFee;
   });
@@ -39,7 +38,7 @@ function validateChainIdsToAffiliates(chainIdsToAffiliates) {
       "basisPointFee does not add up to the same number for each chain in chainIdsToAffiliates"
     );
   }
-  return firstAffiliateBasisPointsFee == null ? void 0 : firstAffiliateBasisPointsFee.toFixed(0);
+  return firstAffiliateBasisPointsFee?.toFixed(0);
 }
 
 export { setApiOptions };

package/dist/chunk-URLFWBSC.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var chunkHAR3IXDE_cjs = require('./chunk-HAR3IXDE.cjs');
+
+// src/api/getAssetsBetweenChains.ts
+var assetsBetweenChains = chunkHAR3IXDE_cjs.api({
+  methodName: "fungibleAssetsBetweenChainsCreate",
+  path: "/v2/fungible/assets_between_chains"
+});
+
+exports.assetsBetweenChains = assetsBetweenChains;

package/dist/chunk-VI7UMBQ7.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkHAR3IXDE_cjs = require('./chunk-HAR3IXDE.cjs');
+
+// src/api/getBridges.ts
+var bridges = chunkHAR3IXDE_cjs.api({
+  methodName: "getBridges",
+  path: "/v2/info/bridges",
+  transformResponse: (response) => response.bridges
+});
+
+exports.bridges = bridges;

package/dist/{chunk-2F4MBSMT.mjs → chunk-VMPFHQ7U.js}

@@ -1,11 +1,9 @@
-import { DEFAULT_GAS_DENOM_OVERRIDES } from './chunk-ZAF3Z56R.mjs';
-import { chains } from './chunk-NU7MCJOK.mjs';
-import { ClientState } from './chunk-DKIWPD5I.mjs';
-import { __async } from './chunk-RXWDHQLG.mjs';
+import { DEFAULT_GAS_DENOM_OVERRIDES } from './chunk-SWYON2RG.js';
+import { chains } from './chunk-JTIHU43D.js';
+import { ClientState } from './chunk-BRMONS6A.js';
 
 // src/private-functions/getDefaultGasTokenForChain.ts
-var getDefaultGasTokenForChain = (chainId) => __async(void 0, null, function* () {
-  var _a;
+var getDefaultGasTokenForChain = async (chainId) => {
   const gasDenom = DEFAULT_GAS_DENOM_OVERRIDES[chainId];
   if (gasDenom) {
     return gasDenom;
@@ -20,10 +18,7 @@ var getDefaultGasTokenForChain = (chainId) => __async(void 0, null, function* ()
   const stakingTokens = 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);
-      }
+      (feeToken) => feeToken.denom === stakingTokens[0]?.denom
     );
     if (feeAsset) {
       return feeAsset.denom;
@@ -39,8 +34,8 @@ var getDefaultGasTokenForChain = (chainId) => __async(void 0, null, function* ()
   if (nonL2Asset) {
     return nonL2Asset.denom;
   }
-  return (_a = chain.fees.fee_tokens[0]) == null ? void 0 : _a.denom;
-});
+  return chain.fees.fee_tokens[0]?.denom;
+};
 var getStakingTokensForChain = (chainId) => {
   const chain = chains().find((chain2) => chain2.chain_id === chainId);
   if (!chain) {
@@ -55,20 +50,19 @@ var getStakingTokensForChain = (chainId) => {
 };
 
 // src/public-functions/getFeeInfoForChain.ts
-var getFeeInfoForChain = (_0) => __async(void 0, [_0], function* ({ chainId, apiUrl, apiKey }) {
-  var _a, _b, _c, _d, _e;
-  const skipChains = yield ClientState.getSkipChains({ apiUrl, apiKey });
+var getFeeInfoForChain = async ({ chainId, apiUrl, apiKey }) => {
+  const skipChains = await ClientState.getSkipChains({ apiUrl, apiKey });
   const skipChain = skipChains.find((chain2) => chain2.chainId === chainId);
   if (!skipChain) {
     return void 0;
   }
-  const defaultGasToken = yield getDefaultGasTokenForChain(chainId);
+  const defaultGasToken = await getDefaultGasTokenForChain(chainId);
   if (!defaultGasToken && !skipChain.feeAssets) {
     return void 0;
   }
-  const skipFeeInfo = defaultGasToken ? (_a = skipChain.feeAssets) == null ? void 0 : _a.find((skipFee) => skipFee.denom === defaultGasToken) : (_b = skipChain.feeAssets) == null ? void 0 : _b[0];
-  if (!skipFeeInfo && ((_d = (_c = skipChain.feeAssets) == null ? void 0 : _c[0]) == null ? void 0 : _d.gasPrice) !== null) {
-    return (_e = skipChain.feeAssets) == null ? void 0 : _e[0];
+  const skipFeeInfo = defaultGasToken ? skipChain.feeAssets?.find((skipFee) => skipFee.denom === defaultGasToken) : skipChain.feeAssets?.[0];
+  if (!skipFeeInfo && skipChain.feeAssets?.[0]?.gasPrice !== null) {
+    return skipChain.feeAssets?.[0];
   }
   if (skipFeeInfo && skipFeeInfo.gasPrice !== null) {
     return skipFeeInfo;
@@ -94,6 +88,6 @@ var getFeeInfoForChain = (_0) => __async(void 0, [_0], function* ({ chainId, api
       high: registryFeeInfo.high_gas_price ? `${registryFeeInfo.high_gas_price}` : ""
     }
   };
-});
+};
 
 export { getFeeInfoForChain };