@skip-go/client 1.6.0-alpha.3 → 1.6.0-alpha.5

package/dist/cjs/chunk-4ZIVDKQN.cjs

@@ -0,0 +1,387 @@
+'use strict';
+
+var chunkMUJBB64F_cjs = require('./chunk-MUJBB64F.cjs');
+var chunkEAZQ2ECA_cjs = require('./chunk-EAZQ2ECA.cjs');
+var chunkATW6UNT5_cjs = require('./chunk-ATW6UNT5.cjs');
+var stargate = require('@cosmjs/stargate');
+var utils = require('@cosmjs/utils');
+var binary_js = require('cosmjs-types/binary.js');
+var auth_js = require('cosmjs-types/cosmos/auth/v1beta1/auth.js');
+var coin_js = require('cosmjs-types/cosmos/base/v1beta1/coin.js');
+var protoSigning = require('@cosmjs/proto-signing');
+var keys_js = require('cosmjs-types/cosmos/crypto/secp256k1/keys.js');
+var amino = require('@cosmjs/amino');
+var _m0 = require('protobufjs/minimal.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var _m0__default = /*#__PURE__*/_interopDefault(_m0);
+
+var createBaseVestingAccount = () => {
+  return {
+    // @ts-expect-error
+    baseAccount: void 0,
+    originalVesting: [],
+    delegatedFree: [],
+    delegatedVesting: [],
+    endTime: BigInt(0)
+  };
+};
+var BaseVestingAccount = {
+  encode(message, writer = binary_js.BinaryWriter.create()) {
+    if (message.baseAccount !== void 0) {
+      auth_js.BaseAccount.encode(
+        message.baseAccount,
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    for (const v of message.originalVesting) {
+      coin_js.Coin.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.delegatedFree) {
+      coin_js.Coin.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.delegatedVesting) {
+      coin_js.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_js.BinaryReader ? input : new binary_js.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_js.BaseAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.originalVesting.push(coin_js.Coin.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.delegatedFree.push(coin_js.Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.delegatedVesting.push(coin_js.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_js.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_js.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_js.BinaryReader ? input : new binary_js.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_js.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_js.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_js.BinaryReader ? input : new binary_js.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;
+  }
+};
+function createBaseEthAccount() {
+  return {
+    baseAccount: void 0,
+    codeHash: new Uint8Array()
+  };
+}
+var EthAccount = {
+  typeUrl: "/injective.types.v1beta1.EthAccount",
+  encode(message, writer = _m0__default.default.Writer.create()) {
+    if (message.baseAccount !== void 0) {
+      chunkMUJBB64F_cjs.BaseAccount.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.codeHash.length !== 0) {
+      writer.uint32(18).bytes(message.codeHash);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.default.Reader ? input : new _m0__default.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEthAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseAccount = chunkMUJBB64F_cjs.BaseAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.codeHash = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      baseAccount: chunkMUJBB64F_cjs.isSet(object.baseAccount) ? chunkMUJBB64F_cjs.BaseAccount.fromJSON(object.baseAccount) : void 0,
+      codeHash: chunkMUJBB64F_cjs.isSet(object.codeHash) ? chunkMUJBB64F_cjs.bytesFromBase64(object.codeHash) : new Uint8Array()
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    message.baseAccount !== void 0 && (obj.baseAccount = message.baseAccount ? chunkMUJBB64F_cjs.BaseAccount.toJSON(message.baseAccount) : void 0);
+    message.codeHash !== void 0 && (obj.codeHash = chunkMUJBB64F_cjs.base64FromBytes(message.codeHash !== void 0 ? message.codeHash : new Uint8Array()));
+    return obj;
+  },
+  fromPartial(object) {
+    const message = createBaseEthAccount();
+    message.baseAccount = object.baseAccount !== void 0 && object.baseAccount !== null ? chunkMUJBB64F_cjs.BaseAccount.fromPartial(object.baseAccount) : void 0;
+    message.codeHash = object.codeHash ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object) {
+    const message = createBaseEthAccount();
+    if (object.base_account !== void 0 && object.base_account !== null) {
+      message.baseAccount = chunkMUJBB64F_cjs.BaseAccount.fromAmino(object.base_account);
+    }
+    if (object.code_hash !== void 0 && object.code_hash !== null) {
+      message.codeHash = chunkMUJBB64F_cjs.bytesFromBase64(object.code_hash);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.base_account = message.baseAccount ? chunkMUJBB64F_cjs.BaseAccount.toAmino(message.baseAccount) : void 0;
+    obj.code_hash = message.codeHash ? chunkMUJBB64F_cjs.base64FromBytes(message.codeHash) : void 0;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return EthAccount.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return EthAccount.decode(message.value);
+  },
+  toProto(message) {
+    return EthAccount.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/injective.types.v1beta1.EthAccount",
+      value: EthAccount.encode(message).finish()
+    };
+  }
+};
+
+// src/registry.ts
+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 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 } = auth_js.BaseAccount.decode(
+          acc.value
+        );
+        switch (pubKey?.typeUrl) {
+          case "/initia.crypto.v1beta1.ethsecp256k1.PubKey":
+          case "/ethermint.crypto.v1.ethsecp256k1.PubKey":
+          case "/cosmos.evm.crypto.v1.ethsecp256k1.PubKey": {
+            const { key } = keys_js.PubKey.decode(pubKey.value);
+            const pk = amino.encodeSecp256k1Pubkey(key);
+            return {
+              address,
+              pubkey: pk,
+              accountNumber: Number(accountNumber),
+              sequence: Number(sequence)
+            };
+          }
+        }
+      }
+      return stargate.accountFromAny(acc);
+    }
+  }
+};
+var accountEthParser = (ethAccount, pubKeyTypeUrl = "/injective.crypto.v1beta1.ethsecp256k1.PubKey") => {
+  const account = EthAccount.decode(
+    ethAccount.value
+  );
+  const baseAccount = account.baseAccount;
+  const pubKey = baseAccount.pubKey;
+  return {
+    address: baseAccount.address,
+    pubkey: pubKey ? {
+      type: pubKeyTypeUrl,
+      value: Buffer.from(pubKey.value).toString("base64")
+    } : null,
+    accountNumber: parseInt(baseAccount.accountNumber.toString(), 10),
+    sequence: parseInt(baseAccount.sequence.toString(), 10)
+  };
+};
+
+// src/private-functions/getRpcEndpointForChain.ts
+var getRpcEndpointForChain = async (chainId) => {
+  if (chunkATW6UNT5_cjs.ClientState.endpointOptions.getRpcEndpointForChain) {
+    return chunkATW6UNT5_cjs.ClientState.endpointOptions.getRpcEndpointForChain(chainId);
+  }
+  if (chunkATW6UNT5_cjs.ClientState.endpointOptions.endpoints && chunkATW6UNT5_cjs.ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = chunkATW6UNT5_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 = chunkEAZQ2ECA_cjs.chains().find((chain2) => chain2.chainId === 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 id '${chainId}'`
+    );
+  }
+  const endpoints = chain.apis?.rpc?.map((api) => api.address);
+  const endpoint = await chunkEAZQ2ECA_cjs.findFirstWorkingEndpoint(endpoints, "rpc");
+  if (!endpoint) {
+    throw new Error(
+      `getRpcEndpointForChain error: failed to find RPC endpoint for chain id '${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 (!chunkATW6UNT5_cjs.ClientState.signingStargateClientByChainId?.[chainId]) {
+    const [signer, endpoint] = await Promise.all([
+      getOfflineSigner(chainId),
+      getRpcEndpointForChain(chainId)
+    ]);
+    chunkATW6UNT5_cjs.ClientState.signingStargateClientByChainId[chainId] = await stargate.SigningStargateClient.connectWithSigner(endpoint, signer, {
+      aminoTypes: chunkATW6UNT5_cjs.ClientState.aminoTypes,
+      registry: chunkATW6UNT5_cjs.ClientState.registry,
+      accountParser
+    });
+  }
+  return {
+    stargateClient: chunkATW6UNT5_cjs.ClientState.signingStargateClientByChainId[chainId],
+    signer: await getOfflineSigner(chainId)
+  };
+};
+
+exports.accountParser = accountParser;
+exports.getRpcEndpointForChain = getRpcEndpointForChain;
+exports.getSigningStargateClient = getSigningStargateClient;

package/dist/cjs/chunk-6T4SBY5H.cjs

@@ -0,0 +1,214 @@
+'use strict';
+
+var chunk3KO2DHFX_cjs = require('./chunk-3KO2DHFX.cjs');
+var chunkA3UNNRKD_cjs = require('./chunk-A3UNNRKD.cjs');
+var chunkNCFH5MGF_cjs = require('./chunk-NCFH5MGF.cjs');
+var chunkAUTOIM57_cjs = require('./chunk-AUTOIM57.cjs');
+var chunk2QPPD3BB_cjs = require('./chunk-2QPPD3BB.cjs');
+
+// src/public-functions/executeMultipleRoutes.ts
+var executeMultipleRoutes = async (options) => {
+  const {
+    route,
+    userAddresses,
+    appendCosmosMsgs,
+    postRouteHandler,
+    slippageTolerancePercent,
+    ...restOptions
+  } = options;
+  const addressList = {};
+  for (const [routeKey, routeValue] of Object.entries(route)) {
+    const _userAddresses = userAddresses[routeKey];
+    if (_userAddresses === void 0) {
+      throw new Error(
+        `executeMultipleRoutes error: no user addresses found for route: ${routeKey}`
+      );
+    }
+    const routeAddressList = await chunk3KO2DHFX_cjs.createValidAddressList({
+      userAddresses: _userAddresses,
+      route: routeValue
+    });
+    addressList[routeKey] = routeAddressList;
+  }
+  const msgsResponses = await Promise.all(
+    Object.entries(route).map(async ([routeKey, routeValue]) => {
+      const routeAddressList = addressList[routeKey];
+      if (routeAddressList === void 0) {
+        throw new Error(
+          `executeMultipleRoutes error: address list not found for route ${routeKey}`
+        );
+      }
+      return await chunkNCFH5MGF_cjs.messages({
+        timeoutSeconds: options.timeoutSeconds,
+        amountIn: routeValue?.amountIn,
+        amountOut: routeValue.estimatedAmountOut || "0",
+        sourceAssetChainId: routeValue?.sourceAssetChainId,
+        sourceAssetDenom: routeValue?.sourceAssetDenom,
+        destAssetChainId: routeValue?.destAssetChainId,
+        destAssetDenom: routeValue?.destAssetDenom,
+        operations: routeValue?.operations,
+        addressList: routeAddressList,
+        slippageTolerancePercent: slippageTolerancePercent?.[routeKey] || "1",
+        chainIdsToAffiliates: chunk2QPPD3BB_cjs.ApiState.chainIdsToAffiliates,
+        postRouteHandler: postRouteHandler?.[routeKey],
+        feePayerAddress: options.svmFeePayer?.address
+      });
+    })
+  );
+  let msgsRecord = {};
+  msgsResponses.forEach((msg, index2) => {
+    const routeKey = Object.keys(route)[index2];
+    if (!routeKey) {
+      throw new Error(
+        `executeMultipleRoutes error: route key not found for index ${index2}`
+      );
+    }
+    const addedCosmosMsgs = appendCosmosMsgs?.[routeKey];
+    if (addedCosmosMsgs) {
+      Object.entries(addedCosmosMsgs).forEach(([chainId, msgs]) => {
+        const txIndex = msg?.txs?.findIndex(
+          (tx2) => "cosmosTx" in tx2 && tx2.cosmosTx.chainId === chainId
+        );
+        if (txIndex === void 0 || txIndex === -1) return;
+        const tx = msg?.txs?.[txIndex];
+        if (tx && "cosmosTx" in tx) {
+          tx.cosmosTx.msgs?.unshift(...msgs);
+        }
+      });
+    }
+    msgsRecord[routeKey] = msg;
+  });
+  let transferIndexToRouteKey = void 0;
+  const cosmosTxIndex0Map = /* @__PURE__ */ new Map();
+  let transferIndex = 0;
+  for (const [routeKey, msgs] of Object.entries(msgsRecord)) {
+    const firstTx = msgs?.txs?.[0];
+    if (firstTx && "cosmosTx" in firstTx) {
+      const { chainId, msgs: firstTxMsgs } = firstTx.cosmosTx;
+      if (!transferIndexToRouteKey) {
+        transferIndexToRouteKey = {};
+      }
+      transferIndexToRouteKey[transferIndex] = routeKey;
+      transferIndex++;
+      if (!cosmosTxIndex0Map.has(chainId)) {
+        cosmosTxIndex0Map.set(chainId, {
+          routeKey,
+          firstCosmosTx: firstTx.cosmosTx
+        });
+      } else {
+        const existing = cosmosTxIndex0Map.get(chainId);
+        if (existing && firstTxMsgs) {
+          const modifyTarget = msgsRecord[existing.routeKey]?.txs?.[0];
+          if (modifyTarget && "cosmosTx" in modifyTarget) {
+            modifyTarget.cosmosTx.msgs?.push(...firstTxMsgs);
+            msgsRecord[routeKey]?.txs?.shift();
+          }
+        }
+      }
+    }
+  }
+  Object.entries(msgsRecord).forEach(([routeKey, msgs]) => {
+    if (msgs?.txs?.length === 0) {
+      delete msgsRecord[routeKey];
+    }
+  });
+  let mainRouteId = void 0;
+  let msgsRecordIndexToRouteId = {};
+  let index = 0;
+  const transactionDetailsList = {};
+  const executeTransactionList = {};
+  const mergedMainAndSecondaryRoutes = Object.entries(msgsRecord).length !== Object.entries(route).length;
+  for (const [routeKey, msgsResponse] of Object.entries(msgsRecord)) {
+    const { id: routeId } = chunkA3UNNRKD_cjs.updateRouteDetails({
+      status: "unconfirmed",
+      options: {
+        route: route[routeKey],
+        ...restOptions
+      },
+      mainRouteId,
+      transferIndexToRouteKey
+    });
+    msgsRecordIndexToRouteId[index] = routeId;
+    if (routeKey === "mainRoute") {
+      mainRouteId = routeId;
+    }
+    const { transactionDetails, executeTransaction: _executeTransaction } = await chunk3KO2DHFX_cjs.executeTransactions({
+      ...restOptions,
+      routeId,
+      txs: msgsResponse?.txs,
+      route: route[routeKey],
+      userAddresses: userAddresses[routeKey],
+      isMultiRoutes: true
+    });
+    const executeTransaction = async (index2) => {
+      const txResult = await _executeTransaction(index2);
+      if (routeKey !== "mainRoute" || mergedMainAndSecondaryRoutes) {
+        const relatedRoutes = Object.entries(route).filter(([key]) => key !== "mainRoute").map(([key, route2]) => ({ route: route2, routeKey: key, status: "pending" }));
+        chunkA3UNNRKD_cjs.updateRouteDetails({
+          options: {
+            route: route[routeKey],
+            ...restOptions
+          },
+          routeId: mainRouteId,
+          transferIndexToRouteKey,
+          relatedRoutes
+        });
+      }
+      return txResult;
+    };
+    if (transactionDetails[0]?.chainType === "evm" /* Evm */) {
+      for (const [index2, transactionDetail] of transactionDetails.entries()) {
+        const txResult = await executeTransaction(index2);
+        if (txResult.txHash) {
+          const trackResponse = await chunkAUTOIM57_cjs.trackTransaction({
+            chainId: transactionDetail.chainId,
+            txHash: txResult.txHash,
+            ...options.trackTxPollingOptions
+          });
+          await options?.onTransactionTracked?.({
+            txHash: txResult.txHash,
+            chainId: transactionDetail.chainId,
+            explorerLink: trackResponse.explorerLink
+          });
+          transactionDetail.txHash = txResult.txHash;
+          transactionDetail.explorerLink = trackResponse.explorerLink;
+        }
+      }
+    } else {
+      executeTransactionList[index] = executeTransaction;
+    }
+    transactionDetailsList[index] = transactionDetails;
+    index++;
+  }
+  await Promise.all(
+    Object.entries(msgsRecord).map(([routeKey, msgsResponse], index2) => {
+      return chunkA3UNNRKD_cjs.executeAndSubscribeToRouteStatus({
+        transactionDetails: transactionDetailsList[index2],
+        executeTransaction: executeTransactionList[index2],
+        routeId: msgsRecordIndexToRouteId[index2],
+        options: {
+          route: route[routeKey],
+          userAddresses: userAddresses[routeKey],
+          ...restOptions,
+          onRouteStatusUpdated: (routeStatus) => {
+            const relatedRoutes = Object.entries(route).filter(([key]) => key !== "mainRoute").map(([key, route2]) => ({ route: route2, routeKey: key, status: routeStatus.status }));
+            if (routeKey !== "mainRoute") {
+              chunkA3UNNRKD_cjs.updateRouteDetails({
+                options: {
+                  route: route[routeKey],
+                  ...restOptions
+                },
+                routeId: mainRouteId,
+                transferIndexToRouteKey,
+                relatedRoutes
+              });
+            }
+            options.onRouteStatusUpdated?.(routeStatus);
+          }
+        }
+      });
+    })
+  );
+};
+
+exports.executeMultipleRoutes = executeMultipleRoutes;