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

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

@@ -21,7 +21,6 @@ __export(PoolService_exports, {
   PoolService: () => PoolService
 });
 module.exports = __toCommonJS(PoolService_exports);
-var import_peripheryCompressor = require("../../abi/compressors/peripheryCompressor.js");
 var import_iERC20 = require("../../abi/iERC20.js");
 var import_iERC20ZapperDeposits = require("../../abi/iERC20ZapperDeposits.js");
 var import_iETHZapperDeposits = require("../../abi/iETHZapperDeposits.js");
@@ -29,59 +28,18 @@ var import_iZapper = require("../../abi/iZapper.js");
 var import_v300 = require("../../abi/v300.js");
 var import_base = require("../base/index.js");
 var import__ = require("../index.js");
-var import_extraZappers = require("./extraZappers.js");
+var import_utils = require("../utils/index.js");
 const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+const POOL_TOKENS_TO_MIGRATE = new import_utils.AddressMap([
+  // v2 diesels
+  ["0x6CFaF95457d7688022FC53e7AbE052ef8DFBbdBA", "dDAI"],
+  ["0xc411dB5f5Eb3f7d552F9B8454B2D74097ccdE6E3", "dUSDC"],
+  ["0xe753260F1955e8678DCeA8887759e07aa57E8c54", "dWBTC"],
+  ["0xF21fc650C1B34eb0FDE786D52d23dA99Db3D6278", "dWETH"],
+  ["0x2158034dB06f06dcB9A786D2F1F8c38781bA779d", "dwstETH"],
+  ["0x8A1112AFef7F4FC7c066a77AABBc01b3Fff31D47", "dFRAX"]
+]);
 class PoolService extends import_base.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(
-      import__.AP_PERIPHERY_COMPRESSOR,
-      import__.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: import_peripheryCompressor.peripheryCompressorAbi,
-          address: pcAddr,
-          functionName: "getZappers",
-          args: [m.configurator.address, m.pool.pool.address]
-        })
-      ),
-      allowFailure: true,
-      batchSize: 0
-    });
-    this.#zappers = new import__.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 import_extraZappers.extraZappers[this.networkType] ?? []) {
-      this.#addZapper(z);
-    }
-  }
   getDepositTokensIn(pool) {
     const underlying = this.#describeUnderlying(pool);
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
@@ -111,17 +69,24 @@ class PoolService extends import_base.SDKConstruct {
     if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
       switch (underlying.contractType) {
         case import_base.KYC_UNDERLYING_DEFAULT: {
-          return this.#depositMetadata(pool, tokenIn, tokenOut, false);
+          return this.#depositMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
         }
         case import_base.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;
@@ -132,7 +97,7 @@ class PoolService extends import_base.SDKConstruct {
       }
     }
     const { zapper } = meta;
-    if (zapper?.tokenIn.addr === NATIVE_ADDRESS) {
+    if (zapper && (0, import__.hexEq)(zapper.tokenIn.addr, NATIVE_ADDRESS)) {
       return {
         target: zapper.baseParams.addr,
         abi: import_iETHZapperDeposits.iethZapperDepositsAbi,
@@ -169,8 +134,32 @@ class PoolService extends import_base.SDKConstruct {
       };
     }
   }
+  getWithdrawalTokensIn(pool) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#withdrawalTokensIn(pool, false);
+        case import_base.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 import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#withdrawalTokensOut(pool, tokenIn, false);
+        case import_base.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 === import_base.KYC_UNDERLYING_ON_DEMAND) {
@@ -182,40 +171,74 @@ class PoolService extends import_base.SDKConstruct {
         };
       }
     }
-    if (zapper) {
+    if (meta.zapper) {
       return permit ? {
-        target: zapper.zapper,
+        target: meta.zapper.baseParams.addr,
         abi: import_iZapper.iZapperAbi,
         functionName: "redeemWithPermit",
         args: [
           amount,
-          account,
+          wallet,
           permit.deadline,
           permit.v,
           permit.r,
           permit.s
         ]
       } : {
-        target: zapper.zapper,
+        target: meta.zapper.baseParams.addr,
         abi: import_iZapper.iZapperAbi,
         functionName: "redeem",
-        args: [amount, account]
+        args: [amount, wallet]
       };
     }
     return {
       target: pool,
       abi: import_v300.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 import_base.KYC_UNDERLYING_DEFAULT: {
+          return this.#withdrawalMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
+        }
+        case import_base.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 import__.AddressSet();
     if (allowDirectDeposit) {
       result.add(pool.underlying);
     }
-    const zappers = this.zappers.get(poolAddr) ?? [];
+    const zappers = this.#getDepositZappers(poolAddr);
     for (const z of zappers) {
       if ((0, import__.hexEq)(z.tokenOut.addr, poolAddr)) {
         result.add(z.tokenIn.addr);
@@ -228,10 +251,27 @@ class PoolService extends import_base.SDKConstruct {
     }
     return result.asArray();
   }
+  #withdrawalTokensIn(poolAddr, allowDirectDeposit) {
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const result = new import__.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 import__.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 ((0, import__.hexEq)(z.tokenIn.addr, tokenIn)) {
         result.add(z.tokenOut.addr);
@@ -242,20 +282,68 @@ class PoolService extends import_base.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 import__.AddressSet();
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const zappers = this.#getDepositZappers(poolAddr);
+    for (const z of zappers) {
+      if ((0, import__.hexEq)(z.tokenOut.addr, tokenIn)) {
+        result.add(z.tokenIn.addr);
+      }
+    }
+    if (allowDirectDeposit && (0, import__.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 {
@@ -264,31 +352,33 @@ class PoolService extends import_base.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 && !(0, import__.hexEq)(tokenIn, NATIVE_ADDRESS),
+      type
     };
   }
-  #getZapper(pool, tokenIn, tokenOut) {
-    return this.zappers.get(pool)?.find(
-      (z) => (0, import__.hexEq)(z.tokenIn.addr, tokenIn) && (0, import__.hexEq)(z.tokenOut.addr, tokenOut)
-    );
-  }
-  #addZapper(z) {
-    const existing = this.zappers.get(z.pool);
-    if (existing) {
-      const hasZapper = existing.some(
-        (zz) => (0, import__.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/cjs/sdk/sdk-legacy/core/creditAccount.js

@@ -38,6 +38,7 @@ class CreditAccountData_Legacy {
   underlying;
   expirationDate;
   version;
+  investor;
   enabledTokensMask;
   healthFactor;
   baseBorrowRateWithoutFee;
@@ -67,6 +68,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) * import_constants.PERCENTAGE_FACTOR / import_constants.WAD
     );

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

@@ -37,7 +37,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/cjs/sdk/utils/abi-decode.js

@@ -18,11 +18,22 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var abi_decode_exports = {};
 __export(abi_decode_exports, {
-  functionArgsToMap: () => functionArgsToMap
+  functionArgsToMap: () => functionArgsToMap,
+  functionArgsToRecord: () => functionArgsToRecord,
+  getFunctionSignature: () => getFunctionSignature
 });
 module.exports = __toCommonJS(abi_decode_exports);
 var import_viem = require("viem");
 var import_utils = require("../../sdk/utils/index.js");
+function getFunctionSignature(abi, calldataOrSelector) {
+  const selector = calldataOrSelector.slice(0, 10);
+  for (const item of abi) {
+    if (item.type === "function" && (0, import_viem.toFunctionSelector)(item) === selector) {
+      return (0, import_viem.toFunctionSignature)(item);
+    }
+  }
+  throw new Error(`Function with selector ${selector} not found in ABI`);
+}
 function functionArgsToMap(abi, functionName, args) {
   const abiItem = (0, import_viem.getAbiItem)({
     abi,
@@ -52,7 +63,37 @@ function functionArgsToMap(abi, functionName, args) {
   }
   return namedArgs;
 }
+function functionArgsToRecord(abi, functionName, args) {
+  const abiItem = (0, import_viem.getAbiItem)({
+    abi,
+    name: functionName,
+    args
+  });
+  if (!abiItem || abiItem.type !== "function") {
+    throw new import_viem.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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  functionArgsToMap
+  functionArgsToMap,
+  functionArgsToRecord,
+  getFunctionSignature
 });

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

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var sendRawTx_exports = {};
 __export(sendRawTx_exports, {
+  estimateRawTxGas: () => estimateRawTxGas,
   sendRawTx: () => sendRawTx
 });
 module.exports = __toCommonJS(sendRawTx_exports);
@@ -36,7 +37,22 @@ async function sendRawTx(client, params) {
     value: BigInt(tx.value)
   });
 }
+async function estimateRawTxGas(client, params) {
+  const { tx, ...rest } = params;
+  return (0, import_utils.getAction)(
+    client,
+    import_actions.estimateGas,
+    "estimateGas"
+  )({
+    ...rest,
+    account: params.account,
+    data: tx.callData,
+    to: tx.to,
+    value: BigInt(tx.value)
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  estimateRawTxGas,
   sendRawTx
 });