@gearbox-protocol/sdk 13.0.0-next.3 → 13.0.0-next.31

package/dist/esm/sdk/pools/PoolService.js

@@ -1,4 +1,3 @@
-import { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
 import { ierc20Abi } from "../../abi/iERC20.js";
 import { ierc20ZapperDepositsAbi } from "../../abi/iERC20ZapperDeposits.js";
 import { iethZapperDepositsAbi } from "../../abi/iETHZapperDeposits.js";
@@ -9,66 +8,19 @@ import {
   KYC_UNDERLYING_ON_DEMAND,
   SDKConstruct
 } from "../base/index.js";
-import {
-  AddressMap,
-  AddressSet,
-  AP_PERIPHERY_COMPRESSOR,
-  hexEq,
-  VERSION_RANGE_310
-} from "../index.js";
-import { extraZappers } from "./extraZappers.js";
+import { AddressSet, hexEq } from "../index.js";
+import { AddressMap } from "../utils/index.js";
 const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+const POOL_TOKENS_TO_MIGRATE = new AddressMap([
+  // v2 diesels
+  ["0x6CFaF95457d7688022FC53e7AbE052ef8DFBbdBA", "dDAI"],
+  ["0xc411dB5f5Eb3f7d552F9B8454B2D74097ccdE6E3", "dUSDC"],
+  ["0xe753260F1955e8678DCeA8887759e07aa57E8c54", "dWBTC"],
+  ["0xF21fc650C1B34eb0FDE786D52d23dA99Db3D6278", "dWETH"],
+  ["0x2158034dB06f06dcB9A786D2F1F8c38781bA779d", "dwstETH"],
+  ["0x8A1112AFef7F4FC7c066a77AABBc01b3Fff31D47", "dFRAX"]
+]);
 class PoolService extends SDKConstruct {
-  #zappers;
-  get zappers() {
-    if (!this.#zappers) {
-      throw new Error("zappers not loaded, call loadZappers first");
-    }
-    return this.#zappers;
-  }
-  async loadZappers(force) {
-    if (!force && this.#zappers) {
-      return;
-    }
-    const [pcAddr] = this.sdk.addressProvider.mustGetLatest(
-      AP_PERIPHERY_COMPRESSOR,
-      VERSION_RANGE_310
-    );
-    this.logger?.debug(`loading zappers with periphery compressor ${pcAddr}`);
-    const markets = this.sdk.marketRegister.markets;
-    const resp = await this.client.multicall({
-      contracts: markets.map(
-        (m) => ({
-          abi: peripheryCompressorAbi,
-          address: pcAddr,
-          functionName: "getZappers",
-          args: [m.configurator.address, m.pool.pool.address]
-        })
-      ),
-      allowFailure: true,
-      batchSize: 0
-    });
-    this.#zappers = new AddressMap(void 0, "zappers");
-    for (let i = 0; i < resp.length; i++) {
-      const { status, result, error } = resp[i];
-      const marketConfigurator = markets[i].configurator.address;
-      const pool = markets[i].pool.pool.address;
-      if (status === "success") {
-        for (const z of result) {
-          this.#addZapper({ ...z, pool });
-        }
-      } else {
-        this.sdk.logger?.error(
-          `failed to load zapper for market configurator ${this.labelAddress(
-            marketConfigurator
-          )} and pool ${this.labelAddress(pool)}: ${error}`
-        );
-      }
-    }
-    for (const z of extraZappers[this.networkType] ?? []) {
-      this.#addZapper(z);
-    }
-  }
   getDepositTokensIn(pool) {
     const underlying = this.#describeUnderlying(pool);
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
@@ -98,17 +50,24 @@ class PoolService extends SDKConstruct {
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
       switch (underlying.contractType) {
         case KYC_UNDERLYING_DEFAULT: {
-          return this.#depositMetadata(pool, tokenIn, tokenOut, false);
+          return this.#depositMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
         }
         case KYC_UNDERLYING_ON_DEMAND:
           return {
             zapper: void 0,
             approveTarget: underlying.liquidityProvider,
-            permissible: false
+            permissible: false,
+            type: "kyc-on-demand"
           };
       }
     }
-    return this.#depositMetadata(pool, tokenIn, tokenOut, true);
+    return this.#depositMetadata("classic", pool, tokenIn, tokenOut, true);
   }
   addLiquidity(props) {
     const { collateral, meta, permit, referralCode, pool, wallet } = props;
@@ -119,7 +78,7 @@ class PoolService extends SDKConstruct {
       }
     }
     const { zapper } = meta;
-    if (zapper?.tokenIn.addr === NATIVE_ADDRESS) {
+    if (zapper && hexEq(zapper.tokenIn.addr, NATIVE_ADDRESS)) {
       return {
         target: zapper.baseParams.addr,
         abi: iethZapperDepositsAbi,
@@ -156,8 +115,32 @@ class PoolService extends SDKConstruct {
       };
     }
   }
+  getWithdrawalTokensIn(pool) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case KYC_UNDERLYING_DEFAULT:
+          return this.#withdrawalTokensIn(pool, false);
+        case KYC_UNDERLYING_ON_DEMAND:
+          return [];
+      }
+    }
+    return this.#withdrawalTokensIn(pool, true);
+  }
+  getWithdrawalTokensOut(pool, tokenIn) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case KYC_UNDERLYING_DEFAULT:
+          return this.#withdrawalTokensOut(pool, tokenIn, false);
+        case KYC_UNDERLYING_ON_DEMAND:
+          return [underlying.asset];
+      }
+    }
+    return this.#withdrawalTokensOut(pool, tokenIn, true);
+  }
   removeLiquidity(props) {
-    const { pool, amount, account, zapper, permit } = props;
+    const { pool, amount, meta, wallet, permit } = props;
     const underlying = this.#describeUnderlying(pool);
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
       if (underlying.contractType === KYC_UNDERLYING_ON_DEMAND) {
@@ -169,40 +152,74 @@ class PoolService extends SDKConstruct {
         };
       }
     }
-    if (zapper) {
+    if (meta.zapper) {
       return permit ? {
-        target: zapper.zapper,
+        target: meta.zapper.baseParams.addr,
         abi: iZapperAbi,
         functionName: "redeemWithPermit",
         args: [
           amount,
-          account,
+          wallet,
           permit.deadline,
           permit.v,
           permit.r,
           permit.s
         ]
       } : {
-        target: zapper.zapper,
+        target: meta.zapper.baseParams.addr,
         abi: iZapperAbi,
         functionName: "redeem",
-        args: [amount, account]
+        args: [amount, wallet]
       };
     }
     return {
       target: pool,
       abi: iPoolV300Abi,
       functionName: "redeem",
-      args: [amount, account, account]
+      args: [amount, wallet, wallet]
     };
   }
+  getWithdrawalMetadata(pool, tokenIn, tokenOut) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case KYC_UNDERLYING_DEFAULT: {
+          return this.#withdrawalMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
+        }
+        case KYC_UNDERLYING_ON_DEMAND:
+          return {
+            zapper: void 0,
+            approveTarget: void 0,
+            permissible: false,
+            type: "kyc-on-demand"
+          };
+      }
+    }
+    return this.#withdrawalMetadata("classic", pool, tokenIn, tokenOut, true);
+  }
+  /**
+   * Filter out v2 diesel tokens (can come from migration v2 -> v3 zappers)
+   * Also omits "migration" zappers (v3 -> v3.1) since they are treated in a different way
+   */
+  #getDepositZappers(poolAddr) {
+    const zappers = this.sdk.marketRegister.poolZappers(poolAddr);
+    return zappers.filter(
+      (z) => z.type !== "migration" && !POOL_TOKENS_TO_MIGRATE.has(z.tokenIn.addr)
+    );
+  }
   #depositTokensIn(poolAddr, allowDirectDeposit) {
     const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
     const result = new AddressSet();
     if (allowDirectDeposit) {
       result.add(pool.underlying);
     }
-    const zappers = this.zappers.get(poolAddr) ?? [];
+    const zappers = this.#getDepositZappers(poolAddr);
     for (const z of zappers) {
       if (hexEq(z.tokenOut.addr, poolAddr)) {
         result.add(z.tokenIn.addr);
@@ -215,10 +232,27 @@ class PoolService extends SDKConstruct {
     }
     return result.asArray();
   }
+  #withdrawalTokensIn(poolAddr, allowDirectDeposit) {
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const result = new AddressSet();
+    if (allowDirectDeposit && pool) {
+      result.add(poolAddr);
+    }
+    const zappers = this.#getDepositZappers(poolAddr);
+    for (const z of zappers) {
+      result.add(z.tokenOut.addr);
+    }
+    if (result.size === 0) {
+      throw new Error(
+        `No tokensIn found for pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return result.asArray();
+  }
   #depositTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
     const result = new AddressSet();
     const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
-    const zappers = this.zappers.get(poolAddr) ?? [];
+    const zappers = this.#getDepositZappers(poolAddr);
     for (const z of zappers) {
       if (hexEq(z.tokenIn.addr, tokenIn)) {
         result.add(z.tokenOut.addr);
@@ -229,20 +263,68 @@ class PoolService extends SDKConstruct {
     }
     if (result.size === 0) {
       throw new Error(
-        `No tokensOut found for tokenIn ${this.labelAddress(tokenIn)} on pool ${this.labelAddress(poolAddr)}`
+        `No tokensOut found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} on pool ${this.labelAddress(poolAddr)}`
       );
     }
-    return result.asArray();
+    const r = result.asArray();
+    return r;
   }
-  #depositMetadata(poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
+  #withdrawalTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
+    const result = new AddressSet();
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const zappers = this.#getDepositZappers(poolAddr);
+    for (const z of zappers) {
+      if (hexEq(z.tokenOut.addr, tokenIn)) {
+        result.add(z.tokenIn.addr);
+      }
+    }
+    if (allowDirectDeposit && hexEq(tokenIn, poolAddr)) {
+      result.add(pool.underlying);
+    }
+    if (result.size === 0) {
+      throw new Error(
+        `No tokensOut found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    const r = result.asArray();
+    return r;
+  }
+  /**
+   * Filter out v2 diesel tokens (can come from migration v2 -> v3 zappers)
+   * Also omits "migration" zappers (v3 -> v3.1) since they are treated in a different way
+   */
+  #getDepositZapper(poolAddr, tokenIn, tokenOut) {
+    const zappers = this.sdk.marketRegister.getZapper(poolAddr, tokenIn, tokenOut)?.filter(
+      (z) => z.type !== "migration" && !POOL_TOKENS_TO_MIGRATE.has(z.tokenIn.addr)
+    );
+    if (zappers && zappers.length > 1) {
+      throw new Error(
+        `Multiple zappers found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} and tokenOut ${this.labelAddress(
+          tokenOut
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return zappers?.[0];
+  }
+  #depositMetadata(type, poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
     if (!tokenOut) {
       throw new Error("tokenOut is required for classic pool deposit");
     }
     const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
-    const zapper = this.#getZapper(poolAddr, tokenIn, tokenOut);
+    const zapper = this.#getDepositZapper(poolAddr, tokenIn, tokenOut);
     if (!zapper && !allowDirectDeposit) {
       throw new Error(
-        `No zapper found for tokenIn ${this.labelAddress(tokenIn)} and tokenOut ${this.labelAddress(tokenOut)} on pool ${this.labelAddress(poolAddr)}`
+        `No zapper found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} and tokenOut ${this.labelAddress(
+          tokenOut
+        )} on pool ${this.labelAddress(poolAddr)}`
       );
     }
     return {
@@ -251,31 +333,33 @@ class PoolService extends SDKConstruct {
       approveTarget: zapper?.baseParams.addr ?? pool.pool.address,
       // TODO: instead of permissible, return permitType зависимости от tokenIn
       // "none" | "eip2612" | "dai_like";
-      permissible: !!zapper && tokenIn !== NATIVE_ADDRESS
+      permissible: !!zapper && !hexEq(tokenIn, NATIVE_ADDRESS),
+      type
     };
   }
-  #getZapper(pool, tokenIn, tokenOut) {
-    return this.zappers.get(pool)?.find(
-      (z) => hexEq(z.tokenIn.addr, tokenIn) && hexEq(z.tokenOut.addr, tokenOut)
-    );
-  }
-  #addZapper(z) {
-    const existing = this.zappers.get(z.pool);
-    if (existing) {
-      const hasZapper = existing.some(
-        (zz) => hexEq(zz.baseParams.addr, z.baseParams.addr)
-      );
-      if (!hasZapper) {
-        existing.push(z);
-      }
-    } else {
-      this.zappers.upsert(z.pool, [z]);
+  #withdrawalMetadata(type, poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
+    if (!tokenOut) {
+      throw new Error("tokenOut is required for classic pool deposit");
     }
-    const zappersTokens = [z.tokenIn, z.tokenOut];
-    for (const t of zappersTokens) {
-      this.sdk.tokensMeta.upsert(t.addr, t);
-      this.sdk.setAddressLabel(t.addr, t.symbol);
+    const zapper = this.#getDepositZapper(poolAddr, tokenOut, tokenIn);
+    if (!zapper && !allowDirectDeposit) {
+      throw new Error(
+        `No zapper found for tokenIn ${this.labelAddress(
+          tokenOut
+        )} and tokenOut ${this.labelAddress(
+          tokenIn
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
     }
+    return {
+      zapper,
+      // zapper or pool itself
+      approveTarget: zapper?.baseParams.addr,
+      // TODO: instead of permissible, return permitType зависимости от tokenIn
+      // "none" | "eip2612" | "dai_like";
+      permissible: !!zapper,
+      type
+    };
   }
   #describeUnderlying(pool) {
     const market = this.sdk.marketRegister.findByPool(pool);

package/dist/esm/sdk/sdk-legacy/core/creditAccount.js

@@ -24,6 +24,7 @@ class CreditAccountData_Legacy {
   underlying;
   expirationDate;
   version;
+  investor;
   enabledTokensMask;
   healthFactor;
   baseBorrowRateWithoutFee;
@@ -53,6 +54,7 @@ class CreditAccountData_Legacy {
     this.underlying = payload.underlying.toLowerCase();
     this.expirationDate = Number(payload.expirationDate);
     this.version = Number(payload.cfVersion);
+    this.investor = payload.investor.toLowerCase();
     this.healthFactor = Number(
       (payload.healthFactor || 0n) * PERCENTAGE_FACTOR / WAD
     );

package/dist/esm/sdk/utils/AddressMap.js

@@ -14,7 +14,7 @@ class AddressMap {
     this.#name = name;
   }
   /**
-   * Adds or updates value, undefined removes value
+   * Adds or overwrites value, undefined removes value
    * @param address
    * @param value
    */

package/dist/esm/sdk/utils/abi-decode.js

@@ -1,8 +1,19 @@
 import {
   AbiFunctionNotFoundError,
-  getAbiItem
+  getAbiItem,
+  toFunctionSelector,
+  toFunctionSignature
 } from "viem";
 import { json_stringify } from "../../sdk/utils/index.js";
+function getFunctionSignature(abi, calldataOrSelector) {
+  const selector = calldataOrSelector.slice(0, 10);
+  for (const item of abi) {
+    if (item.type === "function" && toFunctionSelector(item) === selector) {
+      return toFunctionSignature(item);
+    }
+  }
+  throw new Error(`Function with selector ${selector} not found in ABI`);
+}
 function functionArgsToMap(abi, functionName, args) {
   const abiItem = getAbiItem({
     abi,
@@ -32,6 +43,36 @@ function functionArgsToMap(abi, functionName, args) {
   }
   return namedArgs;
 }
+function functionArgsToRecord(abi, functionName, args) {
+  const abiItem = getAbiItem({
+    abi,
+    name: functionName,
+    args
+  });
+  if (!abiItem || abiItem.type !== "function") {
+    throw new AbiFunctionNotFoundError(functionName);
+  }
+  const namedArgs = {};
+  if (Array.isArray(args)) {
+    args.forEach((value, i) => {
+      const input = abiItem.inputs?.[i];
+      const key = input?.name || `${i}`;
+      namedArgs[key] = value;
+    });
+  } else {
+    Object.entries(args || {}).forEach(([key, value]) => {
+      const index = parseInt(key, 10);
+      if (!Number.isNaN(index) && abiItem.inputs?.[index]?.name) {
+        namedArgs[abiItem.inputs[index].name] = value;
+      } else {
+        namedArgs[key] = value;
+      }
+    });
+  }
+  return namedArgs;
+}
 export {
-  functionArgsToMap
+  functionArgsToMap,
+  functionArgsToRecord,
+  getFunctionSignature
 };

package/dist/esm/sdk/utils/viem/sendRawTx.js

@@ -1,4 +1,7 @@
-import { sendTransaction } from "viem/actions";
+import {
+  estimateGas,
+  sendTransaction
+} from "viem/actions";
 import { getAction } from "viem/utils";
 async function sendRawTx(client, params) {
   const { tx, ...rest } = params;
@@ -13,6 +16,21 @@ async function sendRawTx(client, params) {
     value: BigInt(tx.value)
   });
 }
+async function estimateRawTxGas(client, params) {
+  const { tx, ...rest } = params;
+  return getAction(
+    client,
+    estimateGas,
+    "estimateGas"
+  )({
+    ...rest,
+    account: params.account,
+    data: tx.callData,
+    to: tx.to,
+    value: BigInt(tx.value)
+  });
+}
 export {
+  estimateRawTxGas,
   sendRawTx
 };