@gearbox-protocol/sdk 13.0.0-next.9 → 13.0.1

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

@@ -1,442 +0,0 @@
-import { parseAbi } from "abitype";
-import { encodeFunctionData } from "viem";
-import { iBaseRewardPoolAbi } from "../../abi/iBaseRewardPool.js";
-import { NOT_DEPLOYED } from "../constants/addresses.js";
-import { MAX_UINT256 } from "../constants/math.js";
-import {
-  auraStakedTokens,
-  auraTokens,
-  contractsByNetwork,
-  convexStakedPhantomTokens,
-  convexTokens,
-  getTokenSymbol_Legacy,
-  isAuraStakedToken,
-  isConvexStakedPhantomToken,
-  isStakingRewardsPhantomToken,
-  stakingRewardsTokens,
-  tokenDataByNetwork
-} from "../sdk-gov-legacy/index.js";
-import { AbstractCreditAccountService } from "./AbstractCreditAccountsService.js";
-class CreditAccountServiceV300 extends 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({
-      creditManager: creditAccount.creditManager,
-      creditAccount
-    });
-    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({
-      creditManager: ca.creditManager,
-      creditAccount: ca
-    });
-    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, 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({
-      creditManager: ca.creditManager,
-      creditAccount: ca
-    });
-    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, 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({
-      creditManager: ca.creditManager,
-      creditAccount: ca
-    });
-    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 };
-  }
-  async previewWithdrawLlamathenaProportionally({
-    llamathena
-  }) {
-    const LLAMATHENA_CURVE_POOL = "0xd29f8980852c2c76fc3f6e96a7aa06e0bedcc1b1".toLowerCase();
-    const llamathenaBalance = llamathena.balance;
-    if (llamathenaBalance === 0n) {
-      return {
-        stkLlamathena: [llamathena],
-        assets: [
-          {
-            token: LLAMATHENA_CURVE_POOL,
-            balance: 0n
-          }
-        ]
-      };
-    }
-    return {
-      stkLlamathena: [llamathena],
-      assets: [
-        {
-          token: LLAMATHENA_CURVE_POOL,
-          balance: llamathenaBalance
-        }
-      ]
-    };
-  }
-  async withdrawLlamathenaProportionally({
-    preview,
-    creditAccount: ca,
-    minQuota,
-    averageQuota
-  }) {
-    const LLAMATHENA_BASE_REWARD_POOL = "0x11fd8801a051b296e337a3e1168839fb346d5940";
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
-    const priceUpdatesCalls = await this.getPriceUpdatesForFacade({
-      creditManager: ca.creditManager,
-      creditAccount: ca,
-      desiredQuotas: averageQuota
-    });
-    const baseRewardPoolAdapter = cm.creditManager.adapters.get(
-      LLAMATHENA_BASE_REWARD_POOL
-    );
-    if (!baseRewardPoolAdapter) {
-      throw new Error("BaseRewardPool adapter for llamathena is missing");
-    }
-    const storeExpectedBalances = {
-      target: cm.creditFacade.address,
-      callData: encodeFunctionData({
-        abi: cm.creditFacade.abi,
-        functionName: "storeExpectedBalances",
-        args: [
-          [
-            {
-              token: preview.assets[0].token,
-              amount: preview.assets[0].balance
-            }
-          ]
-        ]
-      })
-    };
-    const withdrawAndUnwrapCall = {
-      target: baseRewardPoolAdapter.address,
-      callData: encodeFunctionData({
-        abi: iBaseRewardPoolAbi,
-        functionName: "withdrawAndUnwrap",
-        args: [preview.stkLlamathena[0].balance, false]
-      })
-    };
-    const compareBalances = {
-      target: cm.creditFacade.address,
-      callData: encodeFunctionData({
-        abi: cm.creditFacade.abi,
-        functionName: "compareBalances",
-        args: []
-      })
-    };
-    const swapCalls = [
-      storeExpectedBalances,
-      withdrawAndUnwrapCall,
-      compareBalances
-    ];
-    const calls = [
-      ...priceUpdatesCalls,
-      ...swapCalls,
-      ...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.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(
-      contractsByNetwork[network]
-    ).reduce(
-      (acc, [symbol, address]) => {
-        if (!!address && address !== NOT_DEPLOYED) {
-          acc[symbol] = address.toLowerCase();
-        }
-        return acc;
-      },
-      {}
-    );
-    const currentTokenData = Object.entries(tokenDataByNetwork[network]).reduce(
-      (acc, [symbol, address]) => {
-        if (!!address && address !== NOT_DEPLOYED) {
-          acc[symbol] = address.toLowerCase();
-        }
-        return acc;
-      },
-      {}
-    );
-    const { aura, convex, sky } = assets.reduce(
-      (acc, a) => {
-        const symbol = getTokenSymbol_Legacy(a.token);
-        if (isConvexStakedPhantomToken(symbol)) {
-          acc.convex.push(a);
-        } else if (isAuraStakedToken(symbol)) {
-          acc.aura.push(a);
-        } else if (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 = getTokenSymbol_Legacy(a.token);
-      const info = convexTokens[symbol || ""];
-      const poolAddress = currentContractsData[info?.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 = getTokenSymbol_Legacy(a.token);
-      const info = auraTokens[symbol || ""];
-      const poolAddress = currentContractsData[info?.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 = getTokenSymbol_Legacy(
-        a.token
-      );
-      const info = stakingRewardsTokens[symbol || ""];
-      const poolAddress = currentContractsData[info?.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 = getTokenSymbol_Legacy(a.token);
-      if (isConvexStakedPhantomToken(symbol)) {
-        return {
-          ...a,
-          token: currentTokenData[convexStakedPhantomTokens[symbol].underlying]
-        };
-      }
-      if (isAuraStakedToken(symbol)) {
-        return {
-          ...a,
-          token: currentTokenData[auraStakedTokens[symbol].underlying]
-        };
-      }
-      if (isStakingRewardsPhantomToken(symbol)) {
-        return {
-          ...a,
-          token: currentTokenData[stakingRewardsTokens[symbol].underlying]
-        };
-      }
-      return a;
-    });
-    return { unwrapCalls, assetsToWithdraw: withdraw };
-  }
-  #withdrawAndUnwrap_Convex(address, amount, claim) {
-    return {
-      target: address,
-      callData: encodeFunctionData({
-        abi: parseAbi([
-          "function withdrawAndUnwrap(uint256, bool claim) returns (uint256 tokensToEnable, uint256 tokensToDisable)"
-        ]),
-        functionName: "withdrawAndUnwrap",
-        args: [amount, claim]
-      })
-    };
-  }
-  #withdrawAllAndUnwrap_Convex(address, claim) {
-    return {
-      target: address,
-      callData: encodeFunctionData({
-        abi: parseAbi([
-          "function withdrawDiffAndUnwrap(uint256 leftoverAmount, bool claim) returns (uint256 tokensToEnable, uint256 tokensToDisable)"
-        ]),
-        functionName: "withdrawDiffAndUnwrap",
-        args: [1n, claim]
-      })
-    };
-  }
-  #withdrawAll_Rewards(address) {
-    return {
-      target: address,
-      callData: encodeFunctionData({
-        abi: parseAbi([
-          "function withdrawDiff(uint256 leftoverAmount) external returns (bool useSafePrices)"
-        ]),
-        functionName: "withdrawDiff",
-        args: [1n]
-      })
-    };
-  }
-  #withdraw_Rewards(address, amount) {
-    return {
-      target: address,
-      callData: encodeFunctionData({
-        abi: parseAbi([
-          "function withdraw(uint256 amount) external returns (bool useSafePrices)"
-        ]),
-        functionName: "withdraw",
-        args: [amount]
-      })
-    };
-  }
-  #claim_Rewards(address) {
-    return {
-      target: address,
-      callData: encodeFunctionData({
-        abi: parseAbi([
-          "function getReward() external returns (bool useSafePrices)"
-        ]),
-        functionName: "getReward",
-        args: []
-      })
-    };
-  }
-}
-export {
-  CreditAccountServiceV300
-};

package/dist/esm/sdk/core/BotListV3Contract.js

@@ -1,77 +0,0 @@
-import { iBotListV300Abi } from "../../abi/v300.js";
-import { BaseContract } from "../base/index.js";
-import { botPermissionsToString } from "../constants/index.js";
-const abi = iBotListV300Abi;
-class BotListContract extends BaseContract {
-  #approvedCreditManagers;
-  #currentBlock;
-  constructor(sdk, address) {
-    super(sdk, { addr: address, name: "BotListV3", abi });
-    this.#currentBlock = sdk.chain.firstBlock ?? 0n;
-  }
-  stringifyFunctionParams(params) {
-    switch (params.functionName) {
-      case "setCreditManagerApprovedStatus": {
-        const [creditManager, status] = params.args;
-        return [this.labelAddress(creditManager), `${status}`];
-      }
-      case "setBotSpecialPermissions": {
-        const [bot, creditManager, permissions] = params.args;
-        return [
-          this.labelAddress(bot),
-          this.labelAddress(creditManager),
-          botPermissionsToString(permissions)
-        ];
-      }
-      default:
-        return super.stringifyFunctionParams(params);
-    }
-  }
-  async syncState(toBlock) {
-    const logs = await this.client.getContractEvents({
-      address: this.address,
-      abi: this.abi,
-      fromBlock: this.#currentBlock,
-      toBlock
-    });
-    logs.forEach((e) => {
-      this.processLog(e);
-    });
-    this.#currentBlock = toBlock;
-  }
-  processLog(log) {
-    switch (log.eventName) {
-      case "SetCreditManagerApprovedStatus":
-        if (log.args.approved) {
-          this.approvedCreditManagers.add(log.args.creditManager);
-        } else {
-          this.approvedCreditManagers.delete(log.args.creditManager);
-        }
-        break;
-      case "SetBotSpecialPermissions":
-        this.logger?.debug(
-          `Bot ${log.args.bot} has been given permissions ${botPermissionsToString(
-            log.args.permissions
-          )} for credit manager ${log.args.creditManager}`
-        );
-        break;
-      default:
-        this.logger?.warn(`Unknown event: ${log.eventName}`);
-        break;
-    }
-  }
-  get approvedCreditManagers() {
-    if (!this.#approvedCreditManagers) {
-      throw new Error(
-        "BotListContract state needs to be synced to load approvedCreditManagers"
-      );
-    }
-    return this.#approvedCreditManagers;
-  }
-  stateHuman(raw = true) {
-    return super.stateHuman(raw);
-  }
-}
-export {
-  BotListContract
-};

package/dist/esm/sdk/core/GearStakingV3Contract.js

@@ -1,59 +0,0 @@
-import { iGearStakingV300Abi } from "../../abi/v300.js";
-import { BaseContract, VotingContractStatus } from "../base/index.js";
-import { ADDRESS_0X0 } from "../constants/index.js";
-const abi = iGearStakingV300Abi;
-class GearStakingContract extends BaseContract {
-  constructor(sdk, address) {
-    super(sdk, { addr: address, name: "GearStakingV3", abi });
-  }
-  stringifyFunctionParams(params) {
-    switch (params.functionName) {
-      case "setVotingContractStatus": {
-        const [address, status] = params.args;
-        return [this.labelAddress(address), VotingContractStatus[status]];
-      }
-      default:
-        return super.stringifyFunctionParams(params);
-    }
-  }
-  stateHuman(raw = true) {
-    return {
-      ...super.stateHuman(raw),
-      successor: this.labelAddress(ADDRESS_0X0),
-      migrator: this.labelAddress(ADDRESS_0X0)
-    };
-  }
-  deposit(amount, votes) {
-    return this.createRawTx({
-      functionName: "deposit",
-      args: [amount, votes]
-    });
-  }
-  depositWithPermit(amount, votes, permit) {
-    return this.createRawTx({
-      functionName: "depositWithPermit",
-      args: [amount, votes, permit.deadline, permit.v, permit.r, permit.s]
-    });
-  }
-  withdraw(amount, to, votes) {
-    return this.createRawTx({
-      functionName: "withdraw",
-      args: [amount, to, votes]
-    });
-  }
-  claimWithdrawals(to) {
-    return this.createRawTx({
-      functionName: "claimWithdrawals",
-      args: [to]
-    });
-  }
-  multivote(votes) {
-    return this.createRawTx({
-      functionName: "multivote",
-      args: [votes]
-    });
-  }
-}
-export {
-  GearStakingContract
-};

package/dist/esm/sdk/core/address-provider/AddressProviderV300Contract.js

@@ -1,82 +0,0 @@
-import { bytesToString, getAbiItem, parseEventLogs, toBytes } from "viem";
-import { iAddressProviderV300Abi } from "../../../abi/v300.js";
-import { getLogsSafe } from "../../utils/viem/index.js";
-import AbstractAddressProviderContract from "./AbstractAddressProviderContract.js";
-const abi = iAddressProviderV300Abi;
-class AddressProviderV300Contract extends AbstractAddressProviderContract {
-  constructor(options, address, version, addresses) {
-    super(
-      options,
-      {
-        addr: address,
-        name: "AddressProviderV300",
-        abi,
-        version
-      },
-      addresses
-    );
-  }
-  stringifyFunctionParams(params) {
-    switch (params.functionName) {
-      case "setAddress": {
-        if (params.args.length !== 3) {
-          const [key2, saveVersion2] = params.args;
-          return [key2, `${saveVersion2}`];
-        }
-        const [key, value, saveVersion] = params.args;
-        return [bytesToString(toBytes(key)), value, `${saveVersion}`];
-      }
-      default:
-        return super.stringifyFunctionParams(params);
-    }
-  }
-  processLog(log) {
-    switch (log.eventName) {
-      case "SetAddress": {
-        const { args } = parseEventLogs({
-          abi: this.abi,
-          eventName: "SetAddress",
-          logs: [log]
-        })[0];
-        const { key, version } = args;
-        this.setInternalAddress(
-          key,
-          log.args.value,
-          Number(version)
-        );
-        break;
-      }
-      default:
-        this.logger?.warn(`Unknown event: ${log.eventName}`);
-        break;
-    }
-  }
-  async syncState(blockNumber) {
-    if (!("firstBlock" in this.chain)) {
-      throw new Error(
-        `address provider v300 requires gearbox chain for ${this.chain.id} `
-      );
-    }
-    const fromBlock = this.chain.firstBlock;
-    this.logger?.debug(
-      `loading events from block ${fromBlock} to ${blockNumber}`
-    );
-    const events = await getLogsSafe(this.client, {
-      address: this.address,
-      event: getAbiItem({ abi: this.abi, name: "SetAddress" }),
-      fromBlock,
-      toBlock: blockNumber,
-      strict: true
-    });
-    for (const event of events) {
-      this.setInternalAddress(
-        event.args.key,
-        event.args.value,
-        Number(event.args.version)
-      );
-    }
-  }
-}
-export {
-  AddressProviderV300Contract
-};

package/dist/esm/sdk/core/address-provider/index.js

@@ -1,4 +0,0 @@
-export * from "./AddressProviderV300Contract.js";
-export * from "./AddressProviderV310Contract.js";
-export * from "./createAddressProvider.js";
-export * from "./types.js";