@gearbox-protocol/sdk 8.3.2 → 8.4.0

package/dist/cjs/sdk/accounts/CreditAccountsServiceV300.js

@@ -0,0 +1,363 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CreditAccountsServiceV300_exports = {};
+__export(CreditAccountsServiceV300_exports, {
+  CreditAccountServiceV300: () => CreditAccountServiceV300
+});
+module.exports = __toCommonJS(CreditAccountsServiceV300_exports);
+var import_abitype = require("abitype");
+var import_viem = require("viem");
+var import_addresses = require("../constants/addresses.js");
+var import_math = require("../constants/math.js");
+var import_sdk_gov_legacy = require("../sdk-gov-legacy/index.js");
+var import_AbstractCreditAccountsService = require("./AbstractCreditAccountsService.js");
+class CreditAccountServiceV300 extends import_AbstractCreditAccountsService.AbstractCreditAccountService {
+  /**
+   * Implements {@link ICreditAccountsService.setBot}
+   */
+  setBot(_) {
+    throw new Error(
+      "Not implemented in router v3.0. Try direct call setBotPermissions instead."
+    );
+  }
+  /**
+   * Implements {@link ICreditAccountsService.withdrawCollateral}
+   */
+  async withdrawCollateral({
+    creditAccount,
+    assetsToWithdraw: wrapped,
+    to,
+    minQuota,
+    averageQuota
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      creditAccount.creditManager,
+      creditAccount,
+      void 0
+    );
+    const { unwrapCalls, assetsToWithdraw } = this.#prepareUnwrapAndWithdrawCallsV3(
+      wrapped,
+      false,
+      false,
+      creditAccount.creditManager
+    );
+    const calls = [
+      ...priceUpdatesCalls,
+      ...unwrapCalls,
+      ...assetsToWithdraw.map(
+        (a) => this.prepareWithdrawToken(
+          creditAccount.creditFacade,
+          a.token,
+          a.balance,
+          to
+        )
+      ),
+      ...this.prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
+    ];
+    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.repayCreditAccount}
+   */
+  async repayCreditAccount({
+    operation,
+    collateralAssets,
+    assetsToWithdraw: wrapped,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const priceUpdates = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const { unwrapCalls, assetsToWithdraw } = this.#prepareUnwrapAndWithdrawCallsV3(
+      wrapped,
+      true,
+      true,
+      ca.creditManager
+    );
+    const calls = [
+      ...operation === "close" ? [] : priceUpdates,
+      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...this.prepareDisableQuotas(ca),
+      ...this.prepareDecreaseDebt(ca),
+      ...unwrapCalls,
+      ...this.prepareDisableTokens(ca),
+      ...assetsToWithdraw.map(
+        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, import_math.MAX_UINT256, to)
+      )
+    ];
+    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.repayAndLiquidateCreditAccount}
+   */
+  async repayAndLiquidateCreditAccount({
+    collateralAssets,
+    assetsToWithdraw: wrapped,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const priceUpdates = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const { unwrapCalls, assetsToWithdraw } = this.#prepareUnwrapAndWithdrawCallsV3(
+      wrapped,
+      true,
+      true,
+      ca.creditManager
+    );
+    const calls = [
+      ...priceUpdates,
+      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...unwrapCalls,
+      ...assetsToWithdraw.map(
+        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, import_math.MAX_UINT256, to)
+      )
+    ];
+    const tx = cm.creditFacade.liquidateCreditAccount(
+      ca.creditAccount,
+      to,
+      calls
+    );
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.claimFarmRewards}
+   */
+  async claimFarmRewards({
+    tokensToDisable,
+    calls: claimCalls,
+    creditAccount: ca,
+    minQuota,
+    averageQuota
+  }) {
+    if (claimCalls.length === 0) throw new Error("No path to execute");
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      averageQuota
+    );
+    const calls = [
+      ...priceUpdatesCalls,
+      ...claimCalls,
+      ...tokensToDisable.map(
+        (a) => this.prepareDisableToken(ca.creditFacade, a.token)
+      ),
+      ...this.prepareUpdateQuotas(ca.creditFacade, { minQuota, averageQuota })
+    ];
+    const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * unwraps staked tokens and optionally claims associated rewards; Should be remove after transition to 3.1
+   * @param acc
+   * @returns
+   */
+  #prepareUnwrapAndWithdrawCallsV3(assets, claim, withdrawAll, creditManager) {
+    const network = this.sdk.provider.networkType;
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const cmAdapters = suite.creditManager.adapters.values().reduce((acc, a) => {
+      const contractLc = a.targetContract.toLowerCase();
+      const adapterLc = a.address.toLowerCase();
+      acc[contractLc] = adapterLc;
+      return acc;
+    }, {});
+    const currentContractsData = Object.entries(
+      import_sdk_gov_legacy.contractsByNetwork[network]
+    ).reduce(
+      (acc, [symbol, address]) => {
+        if (!!address && address !== import_addresses.NOT_DEPLOYED) {
+          acc[symbol] = address.toLowerCase();
+        }
+        return acc;
+      },
+      {}
+    );
+    const currentTokenData = Object.entries(import_sdk_gov_legacy.tokenDataByNetwork[network]).reduce(
+      (acc, [symbol, address]) => {
+        if (!!address && address !== import_addresses.NOT_DEPLOYED) {
+          acc[symbol] = address.toLowerCase();
+        }
+        return acc;
+      },
+      {}
+    );
+    const { aura, convex, sky } = assets.reduce(
+      (acc, a) => {
+        const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+        if ((0, import_sdk_gov_legacy.isConvexStakedPhantomToken)(symbol)) {
+          acc.convex.push(a);
+        } else if ((0, import_sdk_gov_legacy.isAuraStakedToken)(symbol)) {
+          acc.aura.push(a);
+        } else if ((0, import_sdk_gov_legacy.isStakingRewardsPhantomToken)(symbol)) {
+          acc.sky.push(a);
+        }
+        return acc;
+      },
+      { convex: [], aura: [], sky: [] }
+    );
+    const getWithdrawCall = (pool, a) => {
+      return withdrawAll ? this.#withdrawAllAndUnwrap_Convex(pool, claim) : this.#withdrawAndUnwrap_Convex(pool, a.balance, claim);
+    };
+    const getWithdrawCall_Rewards = (pool, a) => {
+      const calls = [
+        withdrawAll ? this.#withdrawAll_Rewards(pool) : this.#withdraw_Rewards(pool, a.balance),
+        ...claim ? [this.#claim_Rewards(pool)] : []
+      ];
+      return calls;
+    };
+    const convexStkCalls = convex.map((a) => {
+      const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+      const { pool } = import_sdk_gov_legacy.convexTokens[symbol];
+      const poolAddress = currentContractsData[pool];
+      if (!poolAddress) {
+        throw new Error("Can't withdrawAllAndUnwrap_Convex (convex)");
+      }
+      const poolAddressLc = poolAddress.toLowerCase();
+      return getWithdrawCall(cmAdapters[poolAddressLc], a);
+    });
+    const auraStkCalls = aura.map((a) => {
+      const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+      const { pool } = import_sdk_gov_legacy.auraTokens[symbol];
+      const poolAddress = currentContractsData[pool];
+      if (!poolAddress) {
+        throw new Error("Can't withdrawAllAndUnwrap_Convex (aura)");
+      }
+      const poolAddressLc = poolAddress.toLowerCase();
+      return getWithdrawCall(cmAdapters[poolAddressLc], a);
+    });
+    const skyStkCalls = sky.flatMap((a) => {
+      const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+      const { pool } = import_sdk_gov_legacy.stakingRewardsTokens[symbol];
+      const poolAddress = currentContractsData[pool];
+      if (!poolAddress) {
+        throw new Error("Can't withdrawAllAndUnwrap_Convex (sky)");
+      }
+      const poolAddressLc = poolAddress.toLowerCase();
+      return getWithdrawCall_Rewards(cmAdapters[poolAddressLc], a);
+    });
+    const unwrapCalls = [...convexStkCalls, ...auraStkCalls, ...skyStkCalls];
+    const withdraw = assets.map((a) => {
+      const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+      if ((0, import_sdk_gov_legacy.isConvexStakedPhantomToken)(symbol)) {
+        return {
+          ...a,
+          token: currentTokenData[import_sdk_gov_legacy.convexStakedPhantomTokens[symbol].underlying]
+        };
+      }
+      if ((0, import_sdk_gov_legacy.isAuraStakedToken)(symbol)) {
+        return {
+          ...a,
+          token: currentTokenData[import_sdk_gov_legacy.auraStakedTokens[symbol].underlying]
+        };
+      }
+      if ((0, import_sdk_gov_legacy.isStakingRewardsPhantomToken)(symbol)) {
+        return {
+          ...a,
+          token: currentTokenData[import_sdk_gov_legacy.stakingRewardsTokens[symbol].underlying]
+        };
+      }
+      return a;
+    });
+    return { unwrapCalls, assetsToWithdraw: withdraw };
+  }
+  #withdrawAndUnwrap_Convex(address, amount, claim) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: (0, import_abitype.parseAbi)([
+          "function withdrawAndUnwrap(uint256, bool claim) returns (uint256 tokensToEnable, uint256 tokensToDisable)"
+        ]),
+        functionName: "withdrawAndUnwrap",
+        args: [amount, claim]
+      })
+    };
+  }
+  #withdrawAllAndUnwrap_Convex(address, claim) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: (0, import_abitype.parseAbi)([
+          "function withdrawDiffAndUnwrap(uint256 leftoverAmount, bool claim) returns (uint256 tokensToEnable, uint256 tokensToDisable)"
+        ]),
+        functionName: "withdrawDiffAndUnwrap",
+        args: [1n, claim]
+      })
+    };
+  }
+  #withdrawAll_Rewards(address) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: (0, import_abitype.parseAbi)([
+          "function withdrawDiff(uint256 leftoverAmount) external returns (bool useSafePrices)"
+        ]),
+        functionName: "withdrawDiff",
+        args: [1n]
+      })
+    };
+  }
+  #withdraw_Rewards(address, amount) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: (0, import_abitype.parseAbi)([
+          "function withdraw(uint256 amount) external returns (bool useSafePrices)"
+        ]),
+        functionName: "withdraw",
+        args: [amount]
+      })
+    };
+  }
+  #claim_Rewards(address) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: (0, import_abitype.parseAbi)([
+          "function getReward() external returns (bool useSafePrices)"
+        ]),
+        functionName: "getReward",
+        args: []
+      })
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreditAccountServiceV300
+});

package/dist/cjs/sdk/accounts/CreditAccountsServiceV310.js

@@ -0,0 +1,200 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CreditAccountsServiceV310_exports = {};
+__export(CreditAccountsServiceV310_exports, {
+  CreditAccountServiceV310: () => CreditAccountServiceV310
+});
+module.exports = __toCommonJS(CreditAccountsServiceV310_exports);
+var import_viem = require("viem");
+var import_v310 = require("../../abi/v310.js");
+var import_math = require("../constants/math.js");
+var import_AbstractCreditAccountsService = require("./AbstractCreditAccountsService.js");
+var import_constants = require("./constants.js");
+class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.AbstractCreditAccountService {
+  /**
+   * Implements {@link ICreditAccountsService.setBot}
+   */
+  async setBot({
+    botAddress,
+    botBaseType,
+    stopBot,
+    creditAccount: ca
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const addBotCall = {
+      target: ca.creditFacade,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_v310.iCreditFacadeMulticallV310Abi,
+        functionName: "setBotPermissions",
+        args: [botAddress, stopBot ? 0n : import_constants.PERMISSION_BY_TYPE[botBaseType]]
+      })
+    };
+    const calls = [...priceUpdatesCalls, addBotCall];
+    const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.withdrawCollateral}
+   */
+  async withdrawCollateral({
+    creditAccount,
+    assetsToWithdraw,
+    to,
+    minQuota,
+    averageQuota
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      creditAccount.creditManager,
+      creditAccount,
+      void 0
+    );
+    const calls = [
+      ...priceUpdatesCalls,
+      ...assetsToWithdraw.map(
+        (a) => this.prepareWithdrawToken(
+          creditAccount.creditFacade,
+          a.token,
+          a.balance,
+          to
+        )
+      ),
+      ...this.prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
+    ];
+    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.repayCreditAccount}
+   */
+  async repayCreditAccount({
+    operation,
+    collateralAssets,
+    assetsToWithdraw,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const router = this.sdk.routerFor(ca);
+    const claimPath = await router.findClaimAllRewards({
+      calls: [],
+      creditAccount: ca
+    });
+    const priceUpdates = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const calls = [
+      ...operation === "close" ? [] : priceUpdates,
+      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...this.prepareDisableQuotas(ca),
+      ...this.prepareDecreaseDebt(ca),
+      ...claimPath.calls,
+      ...this.prepareDisableTokens(ca),
+      ...assetsToWithdraw.map(
+        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, import_math.MAX_UINT256, to)
+      )
+    ];
+    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.repayAndLiquidateCreditAccount}
+   */
+  async repayAndLiquidateCreditAccount({
+    collateralAssets,
+    assetsToWithdraw,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const router = this.sdk.routerFor(ca);
+    const claimPath = await router.findClaimAllRewards({
+      calls: [],
+      creditAccount: ca
+    });
+    const priceUpdates = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const calls = [
+      ...priceUpdates,
+      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...claimPath.calls,
+      ...assetsToWithdraw.map(
+        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, import_math.MAX_UINT256, to)
+      )
+    ];
+    const tx = cm.creditFacade.liquidateCreditAccount(
+      ca.creditAccount,
+      to,
+      calls
+    );
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.claimFarmRewards}
+   */
+  async claimFarmRewards({
+    calls: legacyCalls,
+    creditAccount: ca,
+    minQuota,
+    averageQuota
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const router = this.sdk.routerFor(ca);
+    const claimPath = await router.findClaimAllRewards({
+      calls: legacyCalls,
+      creditAccount: ca
+    });
+    if (claimPath.calls.length === 0) throw new Error("No path to execute");
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      averageQuota
+    );
+    const calls = [
+      ...priceUpdatesCalls,
+      ...claimPath.calls,
+      ...this.prepareUpdateQuotas(ca.creditFacade, { minQuota, averageQuota })
+    ];
+    const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreditAccountServiceV310
+});

package/dist/cjs/sdk/accounts/constants.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  PERMISSION_BY_TYPE: () => PERMISSION_BY_TYPE
+});
+module.exports = __toCommonJS(constants_exports);
+var import_bot_permissions = require("../constants/bot-permissions.js");
+const PERMISSION_BY_TYPE = {
+  LIQUIDATION_PROTECTION: BigInt(
+    import_bot_permissions.BotPermissions.ADD_COLLATERAL | import_bot_permissions.BotPermissions.WITHDRAW_COLLATERAL | import_bot_permissions.BotPermissions.DECREASE_DEBT
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PERMISSION_BY_TYPE
+});

package/dist/cjs/sdk/accounts/createCreditAccountService.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createCreditAccountService_exports = {};
+__export(createCreditAccountService_exports, {
+  createCreditAccountService: () => createCreditAccountService
+});
+module.exports = __toCommonJS(createCreditAccountService_exports);
+var import_constants = require("../constants/index.js");
+var import_CreditAccountsServiceV300 = require("./CreditAccountsServiceV300.js");
+var import_CreditAccountsServiceV310 = require("./CreditAccountsServiceV310.js");
+function createCreditAccountService(sdk, version) {
+  if ((0, import_constants.isV300)(version)) {
+    return new import_CreditAccountsServiceV300.CreditAccountServiceV300(sdk);
+  }
+  if ((0, import_constants.isV310)(version)) {
+    return new import_CreditAccountsServiceV310.CreditAccountServiceV310(sdk);
+  }
+  throw new Error(`Unsupported Credit Account Service version ${version}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCreditAccountService
+});

package/dist/cjs/sdk/accounts/index.js

@@ -15,10 +15,12 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var accounts_exports = {};
 module.exports = __toCommonJS(accounts_exports);
-__reExport(accounts_exports, require("./CreditAccountsService.js"), module.exports);
+__reExport(accounts_exports, require("./constants.js"), module.exports);
+__reExport(accounts_exports, require("./createCreditAccountService.js"), module.exports);
 __reExport(accounts_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./CreditAccountsService.js"),
+  ...require("./constants.js"),
+  ...require("./createCreditAccountService.js"),
   ...require("./types.js")
 });

package/dist/cjs/sdk/router/RouterV300Contract.js

@@ -179,6 +179,14 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
       calls: [...result.calls]
     };
   }
+  /**
+   * Implements {@link IRouterContract.findClaimAllRewards}
+   */
+  async findClaimAllRewards(props) {
+    return {
+      calls: props.calls
+    };
+  }
   /**
    * Implements {@link IRouterContract.findBestClosePath}
    */

package/dist/cjs/sdk/router/RouterV310Contract.js

@@ -141,6 +141,30 @@ class RouterV310Contract extends import_AbstractRouterContract.AbstractRouterCon
       calls: [...result.calls]
     };
   }
+  /**
+   * Implements {@link IRouterContract.findClaimAllRewards}
+   */
+  async findClaimAllRewards(props) {
+    const tData = props.creditAccount.tokens.map((a) => ({
+      balance: a.balance,
+      claimRewards: true,
+      leftoverBalance: a.balance,
+      numSplits: 0n,
+      token: a.token
+    }));
+    return {
+      calls: [
+        {
+          target: this.address,
+          callData: (0, import_viem.encodeFunctionData)({
+            abi: this.abi,
+            functionName: "processClaims",
+            args: [props.creditAccount.creditAccount, tData]
+          })
+        }
+      ]
+    };
+  }
   /**
    * Implements {@link IRouterContract.findBestClosePath}
    */