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

package/dist/chunk-3N7XVGLX.js

@@ -1,269 +0,0 @@
-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';
-
-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) => {
-  switch (acc.typeUrl) {
-    case "/stride.vesting.StridePeriodicVestingAccount": {
-      const baseAccount = StridePeriodicVestingAccount.decode(acc.value).baseVestingAccount?.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?.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 = async (chainId) => {
-  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?.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 (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 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 (!ClientState.signingStargateClientByChainId?.[chainId]) {
-    const [signer, endpoint] = await Promise.all([
-      getOfflineSigner(chainId),
-      getRpcEndpointForChain(chainId)
-    ]);
-    ClientState.signingStargateClientByChainId[chainId] = await SigningStargateClient.connectWithSigner(endpoint, signer, {
-      aminoTypes: ClientState.aminoTypes,
-      registry: ClientState.registry,
-      accountParser
-    });
-  }
-  return {
-    stargateClient: ClientState.signingStargateClientByChainId[chainId],
-    signer: await getOfflineSigner(chainId)
-  };
-};
-
-export { accountParser, getRpcEndpointForChain, getSigningStargateClient };