@gearbox-protocol/sdk 14.12.0-next.9 → 14.12.0-test.1

package/dist/esm/dev/withdrawalUtils.js

@@ -0,0 +1,266 @@
+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: "underlying"
+      }
+    ]
+  });
+  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: "getUnclaimedRedeemers",
+    args: [creditAccount]
+  });
+  logger?.debug(
+    `securitize: gateway ${redemptionGateway}, stablecoin ${stableCoinToken}, ${redeemers.length} unclaimed redeemers`
+  );
+  if (redeemers.length === 0) {
+    logger?.warn(
+      `securitize: no unclaimed redeemers found for credit account ${creditAccount}`
+    );
+    return;
+  }
+  for (const redeemer of redeemers) {
+    const [redemptionValue, redeemerBalance] = await anvil.multicall({
+      allowFailure: false,
+      contracts: [
+        {
+          address: redeemer,
+          abi: securitizeRedeemerAbi,
+          functionName: "getCurrentRedemptionValue"
+        },
+        {
+          address: stableCoinToken,
+          abi: erc20Abi,
+          functionName: "balanceOf",
+          args: [redeemer]
+        }
+      ]
+    });
+    if (redemptionValue === 0n) {
+      logger?.debug(
+        `securitize: skipping redeemer ${redeemer} with zero redemption value`
+      );
+      continue;
+    }
+    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/history/populateContractsRegister.js

@@ -1,17 +1,24 @@
 import {
+  custom,
   isHex
 } from "viem";
 import { createAdapter } from "../plugins/adapters/createAdapter.js";
 import {
   bytes32ToString,
-  ChainContractsRegister,
   CreditFacadeV310BaseContract,
+  getNetworkType,
   isV310,
+  OnchainSDK,
   TokensMeta
 } from "../sdk/index.js";
 function populateContractsRegister(options) {
   const { client, deployments, tokens, logger, strict } = options;
-  const register = new ChainContractsRegister(client, logger);
+  const network = getNetworkType(client.chain.id);
+  const sdk = new OnchainSDK(
+    network,
+    { transport: custom({ request: client.request }) },
+    { logger }
+  );
   for (const d of deployments) {
     let contractType;
     if ("contractType" in d) {
@@ -20,16 +27,14 @@ function populateContractsRegister(options) {
       contractType = [d.contractTypePrefix, d.contractTypeSuffix].filter(Boolean).join("::");
     }
     if (contractType === "CREDIT_FACADE" && isV310(d.version)) {
-      new CreditFacadeV310BaseContract(
-        { register, logger },
-        { addr: d.address, version: d.version, contractType }
-      );
+      new CreditFacadeV310BaseContract(sdk, {
+        addr: d.address,
+        version: d.version,
+        contractType
+      });
     } else if (contractType.startsWith("ADAPTER::")) {
       createAdapter(
-        {
-          register,
-          logger
-        },
+        sdk,
         {
           baseParams: {
             addr: d.address,
@@ -43,9 +48,9 @@ function populateContractsRegister(options) {
   }
   const tMetas = tokens instanceof TokensMeta ? tokens.values() : tokens;
   for (const t of tMetas) {
-    register.tokensMeta.upsert(t.addr, t);
+    sdk.tokensMeta.upsert(t.addr, t);
   }
-  return register;
+  return sdk;
 }
 export {
   populateContractsRegister

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 {

package/dist/esm/plugins/adapters/abi/actionAbi.js

@@ -1,9 +1,6 @@
 import { parseAbi, toFunctionSelector } from "viem";
 import { AdapterType } from "../types.js";
 const adapterActionSignatures = {
-  [AdapterType.BALANCER_VAULT]: {
-    310: "function setPoolStatus(bytes32,uint8)"
-  },
   [AdapterType.BALANCER_V3_ROUTER]: {
     310: "function setPoolStatusBatch(address[],bool[])",
     311: "function setPoolStatusBatch((address,uint8)[])"
@@ -14,9 +11,6 @@ const adapterActionSignatures = {
   [AdapterType.CVX_V1_BOOSTER]: {
     310: "function updateSupportedPids()"
   },
-  [AdapterType.EQUALIZER_ROUTER]: {
-    310: "function setPoolStatusBatch((address,address,bool,bool)[])"
-  },
   [AdapterType.INFINIFI_GATEWAY]: {
     310: "function setLockedTokenBatchStatus((address,uint32,bool)[])"
   },
@@ -29,9 +23,6 @@ const adapterActionSignatures = {
   [AdapterType.KELP_WITHDRAWAL]: {
     310: "function setTokensOutBatchStatus((address,address,bool)[])"
   },
-  [AdapterType.KODIAK_ISLAND_GATEWAY]: {
-    310: "function setIslandStatusBatch((address,uint8)[])"
-  },
   [AdapterType.MELLOW_CLAIMER]: {
     310: "function setMultiVaultStatusBatch((address,address,bool)[])"
   },
@@ -48,7 +39,7 @@ const adapterActionSignatures = {
     310: "function setPairStatusBatch((address,address,address,uint8)[])",
     311: "function setPairStatusBatch((address,address,address,uint8,uint8)[])"
   },
-  [AdapterType.TRADER_JOE_ROUTER]: {
+  [AdapterType.TRADERJOE_ROUTER]: {
     310: "function setPoolStatusBatch((address,address,uint256,uint8,bool)[])"
   },
   [AdapterType.UNISWAP_V2_ROUTER]: {