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

package/dist/esm/dev/withdrawalUtils.js

@@ -0,0 +1,259 @@
+import { erc20Abi, hexToString, parseAbi, parseEther } from "viem";
+import { iWithdrawalCompressorV313Abi } from "../abi/IWithdrawalCompressorV313.js";
+import {
+  getNetworkType,
+  getWithdrawalCompressorAddress
+} from "../sdk/index.js";
+import {
+  iMidasDataFeedAbi,
+  iMidasRedemptionVaultAbi,
+  midasGatewayAbi,
+  midasRedeemerAbi,
+  midasRedemptionVaultPhantomTokenAbi,
+  securitizeRedeemerAbi,
+  securitizeRedemptionGatewayAbi,
+  securitizeRedemptionPhantomTokenAbi
+} from "./withdrawalAbi.js";
+const MIDAS_VAULT_ADMIN = "0x2ACB4BdCbEf02f81BF713b696Ac26390d7f79A12";
+const iVersionAbi = parseAbi([
+  "function contractType() external view returns (bytes32)"
+]);
+const iMidasRedemptionVaultExtAbi = 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 = getWithdrawalCompressorAddress(
+    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: 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 = 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: 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: midasRedemptionVaultPhantomTokenAbi,
+        functionName: "gateway"
+      },
+      {
+        address: withdrawalPhantomToken,
+        abi: midasRedemptionVaultPhantomTokenAbi,
+        functionName: "tokenOut"
+      }
+    ]
+  });
+  const midasRedemptionVault = await anvil.readContract({
+    address: gateway,
+    abi: midasGatewayAbi,
+    functionName: "midasRedemptionVault"
+  });
+  const [mTokenDataFeed, requestRedeemer, tokenOutDecimals, redeemers] = await anvil.multicall({
+    allowFailure: false,
+    contracts: [
+      {
+        address: midasRedemptionVault,
+        abi: iMidasRedemptionVaultAbi,
+        functionName: "mTokenDataFeed"
+      },
+      {
+        address: midasRedemptionVault,
+        abi: iMidasRedemptionVaultExtAbi,
+        functionName: "requestRedeemer"
+      },
+      {
+        address: tokenOut,
+        abi: erc20Abi,
+        functionName: "decimals"
+      },
+      {
+        address: gateway,
+        abi: midasGatewayAbi,
+        functionName: "pendingRedeemers",
+        args: [creditAccount]
+      }
+    ]
+  });
+  const mTokenRate = await anvil.readContract({
+    address: mTokenDataFeed,
+    abi: 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: 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: 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: 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: securitizeRedemptionPhantomTokenAbi,
+        functionName: "redemptionGateway"
+      },
+      {
+        address: withdrawalPhantomToken,
+        abi: securitizeRedemptionPhantomTokenAbi,
+        functionName: "stableCoinToken"
+      }
+    ]
+  });
+  const redeemers = await anvil.readContract({
+    address: redemptionGateway,
+    abi: 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: securitizeRedeemerAbi,
+        functionName: "getCurrentRedemptionValue"
+      },
+      {
+        address: stableCoinToken,
+        abi: 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
+  });
+}
+export {
+  makePendingWithdrawalsClaimable
+};

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

@@ -0,0 +1,11 @@
+import { iTumblerV310Abi } from "../../../abi/310/generated.js";
+import { AbstractFactory } from "./abstract-factory.js";
+const abi = iTumblerV310Abi;
+class RateKeeperFactory extends AbstractFactory {
+  constructor() {
+    super(abi);
+  }
+}
+export {
+  RateKeeperFactory
+};

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

@@ -27,6 +27,7 @@ import { CreditFactory } from "./factory/credit-factory.js";
 import { LossPolicyFactory } from "./factory/loss-policy-factory.js";
 import { PoolFactory } from "./factory/pool-factory.js";
 import { PriceOracleFactory } from "./factory/price-oracle-factory.js";
+import { RateKeeperFactory } from "./factory/rate-keeper-factory.js";
 import { AddressProviderContract } from "./index.js";
 const PERIPHERY_DOMAINS = ["ZAPPER", "DEGEN_NFT"];
 const abi = iMarketConfiguratorV310Abi;
@@ -35,12 +36,14 @@ class MarketConfiguratorContract extends BaseContract {
   poolFactory;
   priceOracleFactory;
   lossPolicyFactory;
+  rateKeeperFactory;
   constructor(addr, client) {
     super({ client }, { abi, addr, name: "MarketConfigurator" });
     this.creditFactory = new CreditFactory();
     this.poolFactory = new PoolFactory();
     this.priceOracleFactory = new PriceOracleFactory();
     this.lossPolicyFactory = new LossPolicyFactory();
+    this.rateKeeperFactory = new RateKeeperFactory();
   }
   async getAddressProvider() {
     const addressProvider = await this.contract.read.addressProvider();
@@ -698,6 +701,14 @@ class MarketConfiguratorContract extends BaseContract {
           data: json_stringify(decoded)
         };
       }
+      case "configureRateKeeper": {
+        const [pool, calldata] = args;
+        const decoded = this.rateKeeperFactory.decodeConfig(calldata);
+        return {
+          pool,
+          data: json_stringify(decoded)
+        };
+      }
       case "updateInterestRateModel": {
         const [pool, deployParams] = args;
         return {