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

package/dist/chunk-B72MYSG5.mjs

@@ -0,0 +1,273 @@
+import { chains, findFirstWorkingEndpoint } from './chunk-NU7MCJOK.mjs';
+import { ClientState } from './chunk-DKIWPD5I.mjs';
+import { __async } from './chunk-RXWDHQLG.mjs';
+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';
+
+var createBaseVestingAccount = () => {
+  return {
+    // @ts-expect-error
+    baseAccount: void 0,
+    originalVesting: [],
+    delegatedFree: [],
+    delegatedVesting: [],
+    endTime: BigInt(0)
+  };
+};
+var BaseVestingAccount = {
+  encode(message, writer = BinaryWriter.create()) {
+    if (message.baseAccount !== void 0) {
+      BaseAccount.encode(
+        message.baseAccount,
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    for (const v of message.originalVesting) {
+      Coin.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.delegatedFree) {
+      Coin.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.delegatedVesting) {
+      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 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 = BaseAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.originalVesting.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.delegatedFree.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.delegatedVesting.push(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 = 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.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 BinaryReader ? input : new 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.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 = 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 BinaryReader ? input : new 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) => {
+  var _a;
+  switch (acc.typeUrl) {
+    case "/stride.vesting.StridePeriodicVestingAccount": {
+      const baseAccount = (_a = StridePeriodicVestingAccount.decode(acc.value).baseVestingAccount) == null ? void 0 : _a.baseAccount;
+      assertDefinedAndNotNull(baseAccount);
+      return {
+        address: baseAccount.address,
+        pubkey: baseAccount.pubKey ? decodePubkey(baseAccount.pubKey) : null,
+        accountNumber: Number(baseAccount.accountNumber),
+        sequence: Number(baseAccount.sequence)
+      };
+    }
+    case "/injective.types.v1beta1.EthAccount":
+      return accountEthParser(
+        acc,
+        "/injective.crypto.v1beta1.ethsecp256k1.PubKey"
+      );
+    case "/ethermint.types.v1.EthAccount":
+      return accountEthParser(acc, "/ethermint.crypto.v1.ethsecp256k1.PubKey");
+    default: {
+      if (acc.typeUrl === "/cosmos.auth.v1beta1.BaseAccount") {
+        const { address, pubKey, accountNumber, sequence } = BaseAccount.decode(
+          acc.value
+        );
+        if ((pubKey == null ? void 0 : pubKey.typeUrl) === "/initia.crypto.v1beta1.ethsecp256k1.PubKey") {
+          const { key } = PubKey.decode(pubKey.value);
+          const pk = encodeSecp256k1Pubkey(key);
+          return {
+            address,
+            pubkey: pk,
+            accountNumber: Number(accountNumber),
+            sequence: Number(sequence)
+          };
+        }
+      }
+      return accountFromAny(acc);
+    }
+  }
+};
+
+// src/private-functions/getRpcEndpointForChain.ts
+var getRpcEndpointForChain = (chainId) => __async(void 0, null, function* () {
+  var _a, _b, _c, _d, _e;
+  if (ClientState.endpointOptions.getRpcEndpointForChain) {
+    return ClientState.endpointOptions.getRpcEndpointForChain(chainId);
+  }
+  if (ClientState.endpointOptions.endpoints && ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = 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);
+  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)) {
+    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 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) => __async(void 0, [_0], function* ({
+  chainId,
+  getOfflineSigner
+}) {
+  var _a;
+  if (!getOfflineSigner) {
+    throw new Error("'getCosmosSigner' is not provided or configured in skip router");
+  }
+  if (!((_a = ClientState.signingStargateClientByChainId) == null ? void 0 : _a[chainId])) {
+    const [signer, endpoint] = yield Promise.all([
+      getOfflineSigner(chainId),
+      getRpcEndpointForChain(chainId)
+    ]);
+    ClientState.signingStargateClientByChainId[chainId] = yield SigningStargateClient.connectWithSigner(endpoint, signer, {
+      aminoTypes: ClientState.aminoTypes,
+      registry: ClientState.registry,
+      accountParser
+    });
+  }
+  return {
+    stargateClient: ClientState.signingStargateClientByChainId[chainId],
+    signer: yield getOfflineSigner(chainId)
+  };
+});
+
+export { accountParser, getRpcEndpointForChain, getSigningStargateClient };

package/dist/chunk-C5CGY2X7.mjs

@@ -0,0 +1,10 @@
+import { pollingApi } from './chunk-RXWDHQLG.mjs';
+
+// src/api/postTransactionStatus.ts
+var transactionStatus = pollingApi({
+  methodName: "getTransactionStatusV2",
+  path: "/v2/tx/status",
+  method: "get"
+});
+
+export { transactionStatus };

package/dist/chunk-CAAR7GDJ.mjs

@@ -0,0 +1,11 @@
+import { pollingApi } from './chunk-RXWDHQLG.mjs';
+
+// src/api/postTrackTransaction.ts
+var trackTransaction = pollingApi({
+  methodName: "trackTransactionV2",
+  path: "/v2/tx/track",
+  method: "post",
+  backoffMultiplier: 2.5
+});
+
+export { trackTransaction };

package/dist/chunk-CZ27FEZ7.mjs

@@ -0,0 +1,11 @@
+import { api } from './chunk-RXWDHQLG.mjs';
+
+// src/api/postIbcOriginAssets.ts
+var ibcOriginAssets = api({
+  methodName: "getOriginAssets",
+  method: "post",
+  path: "/v2/fungible/ibc_origin_assets",
+  transformResponse: (response) => response.originAssets
+});
+
+export { ibcOriginAssets };

package/dist/chunk-DKIWPD5I.mjs

@@ -0,0 +1,124 @@
+import { api, __async, __spreadValues, __objRest } from './chunk-RXWDHQLG.mjs';
+
+// src/private-functions/getMainnetAndTestnetChains.ts
+var getMainnetAndTestnetChains = (apiOptions) => __async(void 0, null, function* () {
+  const [mainnetRes, testnetRes] = yield Promise.all([
+    chains(__spreadValues({
+      includeEvm: true,
+      includeSvm: true
+    }, apiOptions)),
+    chains(__spreadValues({
+      includeEvm: true,
+      includeSvm: true,
+      onlyTestnets: true
+    }, apiOptions))
+  ]);
+  const combinedChains = [...mainnetRes != null ? mainnetRes : [], ...testnetRes != null ? testnetRes : []];
+  ClientState.skipChains = combinedChains;
+  return combinedChains;
+});
+
+// src/api/getAssets.ts
+var assets = api({
+  methodName: "getAssets",
+  path: "/v2/fungible/assets",
+  transformResponse: (response) => {
+    return transformAssetsMap(response.chainToAssetsMap);
+  },
+  onSuccess: (response, options) => {
+    if ((options == null ? void 0 : options.includeEvmAssets) && (options == null ? void 0 : options.includeSvmAssets) && (options == null ? void 0 : options.includeCw20Assets)) {
+      ClientState.skipAssets = response;
+    }
+  }
+});
+var transformAssetsMap = (input) => Object.entries(input != null ? input : {}).reduce(
+  (acc, [chainId, { assets: assets2 }]) => {
+    acc[chainId] = (assets2 != null ? assets2 : []).map((asset) => asset);
+    return acc;
+  },
+  {}
+);
+
+// src/private-functions/getMainnetAndTestnetAssets.ts
+var getMainnetAndTestnetAssets = (_a) => __async(void 0, null, function* () {
+  var _b = _a, {
+    chainId
+  } = _b, apiOptions = __objRest(_b, [
+    "chainId"
+  ]);
+  const [assetsMainnet, assetsTestnet] = yield Promise.all([
+    assets(__spreadValues({
+      chainIds: chainId ? [chainId] : void 0
+    }, apiOptions)),
+    assets(__spreadValues({
+      chainIds: chainId ? [chainId] : void 0,
+      onlyTestnets: true
+    }, apiOptions))
+  ]);
+  const mainnet = assetsMainnet;
+  const testnet = assetsTestnet;
+  const merged = __spreadValues(__spreadValues({}, mainnet), testnet);
+  ClientState.skipAssets = merged;
+  return merged;
+});
+
+// src/api/postBalances.ts
+var balances = api({
+  methodName: "getBalances",
+  method: "post",
+  path: "/v2/info/balances",
+  onSuccess: (response, options) => {
+    if (!options) {
+      ClientState.skipBalances = response;
+    }
+  }
+});
+
+// src/state/clientState.ts
+var ClientState = class {
+  static getSkipChains(apiOptions) {
+    return __async(this, null, function* () {
+      if (this.skipChains) {
+        return this.skipChains;
+      }
+      const response = yield getMainnetAndTestnetChains(apiOptions);
+      this.skipChains = response;
+      return response;
+    });
+  }
+  static getSkipAssets(props) {
+    return __async(this, null, function* () {
+      if (this.skipAssets) {
+        return this.skipAssets;
+      }
+      const response = yield getMainnetAndTestnetAssets(props);
+      this.skipAssets = response;
+      return response;
+    });
+  }
+  static getSkipBalances() {
+    return __async(this, null, function* () {
+      if (this.skipBalances) {
+        return this.skipBalances;
+      }
+      const response = yield balances();
+      this.skipBalances = response;
+      return response;
+    });
+  }
+};
+ClientState.signingStargateClientByChainId = {};
+
+// src/api/getChains.ts
+var chains = api({
+  methodName: "getChains",
+  path: "/v2/info/chains",
+  transformResponse: (response) => response.chains,
+  onSuccess: (response, options) => {
+    if ((options == null ? void 0 : options.includeEvm) && (options == null ? void 0 : options.includeSvm)) {
+      ClientState.skipChains = response;
+    }
+  }
+});
+
+export { ClientState, assets, balances, chains, transformAssetsMap };

package/dist/chunk-IGD32L7C.mjs

@@ -0,0 +1,9 @@
+import { api } from './chunk-RXWDHQLG.mjs';
+
+// src/api/getAssetsBetweenChains.ts
+var assetsBetweenChains = api({
+  methodName: "fungibleAssetsBetweenChainsCreate",
+  path: "/v2/fungible/assets_between_chains"
+});
+
+export { assetsBetweenChains };

package/dist/chunk-J7GGREYX.mjs

@@ -0,0 +1,10 @@
+import { api } from './chunk-RXWDHQLG.mjs';
+
+// src/api/getBridges.ts
+var bridges = api({
+  methodName: "getBridges",
+  path: "/v2/info/bridges",
+  transformResponse: (response) => response.bridges
+});
+
+export { bridges };

package/dist/chunk-KPK3Z6QZ.mjs

@@ -0,0 +1,10 @@
+import { api } from './chunk-RXWDHQLG.mjs';
+
+// src/api/postMessages.ts
+var messages = api({
+  methodName: "getMsgsV2",
+  method: "post",
+  path: "/v2/fungible/msgs"
+});
+
+export { messages };