@gearbox-protocol/sdk 14.12.0-next.17 → 14.12.0-next.18

package/dist/cjs/dev/withdrawalUtils.js

@@ -0,0 +1,271 @@
+"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 withdrawalUtils_exports = {};
+__export(withdrawalUtils_exports, {
+  makePendingWithdrawalsClaimable: () => makePendingWithdrawalsClaimable
+});
+module.exports = __toCommonJS(withdrawalUtils_exports);
+var import_viem = require("viem");
+var import_IWithdrawalCompressorV313 = require("../abi/IWithdrawalCompressorV313.js");
+var import_sdk = require("../sdk/index.js");
+var import_withdrawalAbi = require("./withdrawalAbi.js");
+const MIDAS_VAULT_ADMIN = "0x2ACB4BdCbEf02f81BF713b696Ac26390d7f79A12";
+const iVersionAbi = (0, import_viem.parseAbi)([
+  "function contractType() external view returns (bytes32)"
+]);
+const iMidasRedemptionVaultExtAbi = (0, import_viem.parseAbi)([
+  "function requestRedeemer() external view returns (address)",
+  "function safeApproveRequest(uint256 requestId, uint256 newMTokenRate) external"
+]);
+async function makePendingWithdrawalsClaimable(anvil, creditAccount, options) {
+  const { logger, timeWarp = false } = options || {};
+  const compressor = (0, import_sdk.getWithdrawalCompressorAddress)(
+    (0, import_sdk.getNetworkType)(anvil.chain.id)
+  );
+  if (!compressor) {
+    throw new Error(`no withdrawal compressor for chain ${anvil.chain.id}`);
+  }
+  if (compressor.version !== 313) {
+    logger?.warn(
+      `withdrawal compressor version is ${compressor.version}, this helper assumes 313`
+    );
+  }
+  const [, pending] = await anvil.readContract({
+    address: compressor.address,
+    abi: import_IWithdrawalCompressorV313.iWithdrawalCompressorV313Abi,
+    functionName: "getCurrentWithdrawals",
+    args: [creditAccount]
+  });
+  logger?.debug(
+    `found ${pending.length} pending withdrawals for credit account ${creditAccount}`
+  );
+  if (pending.length === 0) {
+    return;
+  }
+  if (timeWarp) {
+    const maxClaimableAt = pending.reduce(
+      (max, p) => p.claimableAt > max ? p.claimableAt : max,
+      0n
+    );
+    if (maxClaimableAt > 0n) {
+      logger?.debug(`warping time to ${maxClaimableAt + 1n}`);
+      await anvil.evmMineDetailed(maxClaimableAt + 1n);
+    }
+  }
+  for (const w of pending) {
+    const cType = (0, import_viem.hexToString)(
+      await anvil.readContract({
+        address: w.withdrawalPhantomToken,
+        abi: iVersionAbi,
+        functionName: "contractType"
+      }),
+      { size: 32 }
+    );
+    logger?.debug(
+      `fulfilling withdrawal in phantom token ${w.withdrawalPhantomToken} with contract type ${cType}`
+    );
+    switch (cType) {
+      case "PHANTOM_TOKEN::MIDAS_REDEMPTION":
+        await fulfillMidasWithdrawal(
+          anvil,
+          creditAccount,
+          w.withdrawalPhantomToken,
+          logger
+        );
+        break;
+      case "PHANTOM_TOKEN::SECURITIZE_RD":
+        await fulfillSecuritizeWithdrawal(
+          anvil,
+          creditAccount,
+          w.withdrawalPhantomToken,
+          logger
+        );
+        break;
+      default:
+        logger?.warn(
+          `unsupported withdrawal phantom token type ${cType}, only time warp was applied`
+        );
+    }
+  }
+  const [claimableAfter, pendingAfter] = await anvil.readContract({
+    address: compressor.address,
+    abi: import_IWithdrawalCompressorV313.iWithdrawalCompressorV313Abi,
+    functionName: "getCurrentWithdrawals",
+    args: [creditAccount]
+  });
+  logger?.debug(
+    `after fulfillment: ${claimableAfter.length} claimable, ${pendingAfter.length} still pending withdrawals`
+  );
+}
+async function fulfillMidasWithdrawal(anvil, creditAccount, withdrawalPhantomToken, logger) {
+  const [gateway, tokenOut] = await anvil.multicall({
+    allowFailure: false,
+    contracts: [
+      {
+        address: withdrawalPhantomToken,
+        abi: import_withdrawalAbi.midasRedemptionVaultPhantomTokenAbi,
+        functionName: "gateway"
+      },
+      {
+        address: withdrawalPhantomToken,
+        abi: import_withdrawalAbi.midasRedemptionVaultPhantomTokenAbi,
+        functionName: "tokenOut"
+      }
+    ]
+  });
+  const midasRedemptionVault = await anvil.readContract({
+    address: gateway,
+    abi: import_withdrawalAbi.midasGatewayAbi,
+    functionName: "midasRedemptionVault"
+  });
+  const [mTokenDataFeed, requestRedeemer, tokenOutDecimals, redeemers] = await anvil.multicall({
+    allowFailure: false,
+    contracts: [
+      {
+        address: midasRedemptionVault,
+        abi: import_withdrawalAbi.iMidasRedemptionVaultAbi,
+        functionName: "mTokenDataFeed"
+      },
+      {
+        address: midasRedemptionVault,
+        abi: iMidasRedemptionVaultExtAbi,
+        functionName: "requestRedeemer"
+      },
+      {
+        address: tokenOut,
+        abi: import_viem.erc20Abi,
+        functionName: "decimals"
+      },
+      {
+        address: gateway,
+        abi: import_withdrawalAbi.midasGatewayAbi,
+        functionName: "pendingRedeemers",
+        args: [creditAccount]
+      }
+    ]
+  });
+  const mTokenRate = await anvil.readContract({
+    address: mTokenDataFeed,
+    abi: import_withdrawalAbi.iMidasDataFeedAbi,
+    functionName: "getDataInBase18"
+  });
+  logger?.debug(
+    `midas: gateway ${gateway}, vault ${midasRedemptionVault}, tokenOut ${tokenOut}, mToken rate ${mTokenRate}, ${redeemers.length} pending redeemers`
+  );
+  for (const redeemer of redeemers) {
+    const topUp = 1000000n * 10n ** BigInt(tokenOutDecimals);
+    const requestRedeemerBalance = await anvil.readContract({
+      address: tokenOut,
+      abi: import_viem.erc20Abi,
+      functionName: "balanceOf",
+      args: [requestRedeemer]
+    });
+    logger?.debug(
+      `midas: dealing ${topUp} of tokenOut ${tokenOut} to request redeemer ${requestRedeemer}`
+    );
+    await anvil.deal({
+      erc20: tokenOut,
+      account: requestRedeemer,
+      amount: requestRedeemerBalance + topUp
+    });
+    const requestId = await anvil.readContract({
+      address: redeemer,
+      abi: import_withdrawalAbi.midasRedeemerAbi,
+      functionName: "requestId"
+    });
+    logger?.debug(
+      `midas: approving request ${requestId} of redeemer ${redeemer} as vault admin ${MIDAS_VAULT_ADMIN}`
+    );
+    await anvil.impersonateAccount({ address: MIDAS_VAULT_ADMIN });
+    await anvil.setBalance({
+      address: MIDAS_VAULT_ADMIN,
+      value: (0, import_viem.parseEther)("100")
+    });
+    await anvil.writeContract({
+      chain: anvil.chain,
+      address: midasRedemptionVault,
+      account: MIDAS_VAULT_ADMIN,
+      abi: iMidasRedemptionVaultExtAbi,
+      functionName: "safeApproveRequest",
+      args: [requestId, mTokenRate]
+    });
+    await anvil.stopImpersonatingAccount({ address: MIDAS_VAULT_ADMIN });
+  }
+}
+async function fulfillSecuritizeWithdrawal(anvil, creditAccount, withdrawalPhantomToken, logger) {
+  const [redemptionGateway, stableCoinToken] = await anvil.multicall({
+    allowFailure: false,
+    contracts: [
+      {
+        address: withdrawalPhantomToken,
+        abi: import_withdrawalAbi.securitizeRedemptionPhantomTokenAbi,
+        functionName: "redemptionGateway"
+      },
+      {
+        address: withdrawalPhantomToken,
+        abi: import_withdrawalAbi.securitizeRedemptionPhantomTokenAbi,
+        functionName: "stableCoinToken"
+      }
+    ]
+  });
+  const redeemers = await anvil.readContract({
+    address: redemptionGateway,
+    abi: import_withdrawalAbi.securitizeRedemptionGatewayAbi,
+    functionName: "getRedeemers",
+    args: [creditAccount]
+  });
+  logger?.debug(
+    `securitize: gateway ${redemptionGateway}, stablecoin ${stableCoinToken}, ${redeemers.length} redeemers`
+  );
+  if (redeemers.length === 0) {
+    logger?.warn(
+      `securitize: no redeemers found for credit account ${creditAccount}`
+    );
+    return;
+  }
+  const redeemer = redeemers[0];
+  const [redemptionValue, redeemerBalance] = await anvil.multicall({
+    allowFailure: false,
+    contracts: [
+      {
+        address: redeemer,
+        abi: import_withdrawalAbi.securitizeRedeemerAbi,
+        functionName: "getCurrentRedemptionValue"
+      },
+      {
+        address: stableCoinToken,
+        abi: import_viem.erc20Abi,
+        functionName: "balanceOf",
+        args: [redeemer]
+      }
+    ]
+  });
+  logger?.debug(
+    `securitize: dealing ${redemptionValue} of stablecoin ${stableCoinToken} to redeemer ${redeemer}`
+  );
+  await anvil.deal({
+    erc20: stableCoinToken,
+    account: redeemer,
+    amount: redeemerBalance + redemptionValue
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makePendingWithdrawalsClaimable
+});

package/dist/cjs/permissionless/bindings/factory/rate-keeper-factory.js

@@ -0,0 +1,35 @@
+"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 rate_keeper_factory_exports = {};
+__export(rate_keeper_factory_exports, {
+  RateKeeperFactory: () => RateKeeperFactory
+});
+module.exports = __toCommonJS(rate_keeper_factory_exports);
+var import_generated = require("../../../abi/310/generated.js");
+var import_abstract_factory = require("./abstract-factory.js");
+const abi = import_generated.iTumblerV310Abi;
+class RateKeeperFactory extends import_abstract_factory.AbstractFactory {
+  constructor() {
+    super(abi);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RateKeeperFactory
+});

package/dist/cjs/permissionless/bindings/market-configurator.js

@@ -32,6 +32,7 @@ var import_credit_factory = require("./factory/credit-factory.js");
 var import_loss_policy_factory = require("./factory/loss-policy-factory.js");
 var import_pool_factory = require("./factory/pool-factory.js");
 var import_price_oracle_factory = require("./factory/price-oracle-factory.js");
+var import_rate_keeper_factory = require("./factory/rate-keeper-factory.js");
 var import_index = require("./index.js");
 const PERIPHERY_DOMAINS = ["ZAPPER", "DEGEN_NFT"];
 const abi = import_generated.iMarketConfiguratorV310Abi;
@@ -40,12 +41,14 @@ class MarketConfiguratorContract extends import_sdk.BaseContract {
   poolFactory;
   priceOracleFactory;
   lossPolicyFactory;
+  rateKeeperFactory;
   constructor(addr, client) {
     super({ client }, { abi, addr, name: "MarketConfigurator" });
     this.creditFactory = new import_credit_factory.CreditFactory();
     this.poolFactory = new import_pool_factory.PoolFactory();
     this.priceOracleFactory = new import_price_oracle_factory.PriceOracleFactory();
     this.lossPolicyFactory = new import_loss_policy_factory.LossPolicyFactory();
+    this.rateKeeperFactory = new import_rate_keeper_factory.RateKeeperFactory();
   }
   async getAddressProvider() {
     const addressProvider = await this.contract.read.addressProvider();
@@ -703,6 +706,14 @@ class MarketConfiguratorContract extends import_sdk.BaseContract {
           data: (0, import_sdk.json_stringify)(decoded)
         };
       }
+      case "configureRateKeeper": {
+        const [pool, calldata] = args;
+        const decoded = this.rateKeeperFactory.decodeConfig(calldata);
+        return {
+          pool,
+          data: (0, import_sdk.json_stringify)(decoded)
+        };
+      }
       case "updateInterestRateModel": {
         const [pool, deployParams] = args;
         return {