@gearbox-protocol/sdk 14.11.3 → 14.12.0-next.10

package/dist/esm/sdk/market/zapper/ZapperContract.js

@@ -0,0 +1,82 @@
+import { iZapperAbi } from "../../../abi/iZapper.js";
+import { BaseContract } from "../../base/index.js";
+import { UnsupportedZapperFunctionError } from "./errors.js";
+class ZapperContract extends BaseContract {
+  sdk;
+  pool;
+  type;
+  baseParams;
+  tokenIn;
+  tokenOut;
+  constructor(sdk, data, abi = iZapperAbi, namePrefix = "Zapper") {
+    super(sdk, {
+      addr: data.baseParams.addr,
+      abi,
+      name: `${namePrefix}(${sdk.labelAddress(data.baseParams.addr)})`,
+      version: data.baseParams.version,
+      contractType: data.baseParams.contractType
+    });
+    this.sdk = sdk;
+    this.pool = data.pool;
+    this.type = data.type;
+    this.baseParams = data.baseParams;
+    this.tokenIn = data.tokenIn;
+    this.tokenOut = data.tokenOut;
+  }
+  /**
+   * Decodes zapper calldata into {@link ParsedZapperOperation}.
+   * Throws {@link UnsupportedZapperFunctionError} for unknown selectors.
+   */
+  parseOperation(calldata, value) {
+    const parsed = this.parseFunctionDataV2(calldata);
+    const { rawArgs } = parsed;
+    const pool = this.pool;
+    const zapper = this.address;
+    const underlying = this.sdk.marketRegister.findByPool(pool).underlying;
+    const receiver = rawArgs.receiver;
+    if (parsed.functionName.startsWith("deposit")) {
+      return {
+        operation: "Deposit",
+        pool,
+        zapper,
+        receiver,
+        assets: rawArgs.tokenInAmount ?? value ?? 0n,
+        underlying,
+        referralCode: rawArgs.referralCode
+      };
+    }
+    if (parsed.functionName.startsWith("redeem")) {
+      return {
+        operation: "Redeem",
+        pool,
+        zapper,
+        receiver,
+        shares: rawArgs.tokenOutAmount,
+        underlying
+      };
+    }
+    throw new UnsupportedZapperFunctionError(zapper, parsed.functionName);
+  }
+  /**
+   * Redeems pool shares (diesel tokens) for the underlying asset via this zapper.
+   */
+  redeem(tokenInAmount, receiver) {
+    return this.createRawTx({
+      functionName: "redeem",
+      args: [tokenInAmount, receiver]
+    });
+  }
+  /**
+   * Redeems pool shares via this zapper with an EIP-2612 permit signature,
+   * skipping a separate approve transaction.
+   */
+  redeemWithPermit(tokenInAmount, receiver, deadline, v, r, s) {
+    return this.createRawTx({
+      functionName: "redeemWithPermit",
+      args: [tokenInAmount, receiver, deadline, v, r, s]
+    });
+  }
+}
+export {
+  ZapperContract
+};

package/dist/esm/sdk/market/zapper/createZapper.js

@@ -1,20 +1,28 @@
+import { bytes32ToString } from "../../utils/index.js";
 import { IERC20ZapperContract } from "./IERC20ZapperContract.js";
 import { IETHZapperContract } from "./IETHZapperContract.js";
-import { Zapper } from "./Zapper.js";
+import { ZapperContract } from "./ZapperContract.js";
 function createZapper(sdk, data) {
+  const existing = sdk.getContract(data.baseParams.addr);
+  if (existing) {
+    return existing;
+  }
   if (data.type === "base") {
-    const contractType = Zapper.contractType(data.baseParams);
+    const contractType = bytes32ToString(data.baseParams.contractType);
     switch (contractType) {
       case "ZAPPER::ERC4626_UNDERLYING":
         return new IERC20ZapperContract(sdk, data);
       case "ZAPPER::WETH_DEPOSIT":
         return new IETHZapperContract(sdk, data);
       default:
+        if (sdk.strictContractTypes) {
+          throw new Error(`Unknown zapper contract type: ${contractType}`);
+        }
         sdk.logger?.warn(`Unknown zapper contract type: ${contractType}`);
-        return new Zapper(data);
+        return new ZapperContract(sdk, data);
     }
   }
-  return new Zapper(data);
+  return new ZapperContract(sdk, data);
 }
 export {
   createZapper

package/dist/esm/sdk/market/zapper/errors.js

@@ -0,0 +1,13 @@
+class UnsupportedZapperFunctionError extends Error {
+  zapper;
+  functionName;
+  constructor(zapper, functionName) {
+    super(`unsupported zapper function "${functionName}" on ${zapper}`);
+    this.name = "UnsupportedZapperFunctionError";
+    this.zapper = zapper;
+    this.functionName = functionName;
+  }
+}
+export {
+  UnsupportedZapperFunctionError
+};

package/dist/esm/sdk/market/zapper/index.js

@@ -1,4 +1,6 @@
 export * from "./createZapper.js";
+export * from "./errors.js";
 export * from "./IERC20ZapperContract.js";
 export * from "./IETHZapperContract.js";
-export * from "./Zapper.js";
+export * from "./types.js";
+export * from "./ZapperContract.js";

package/dist/esm/sdk/options.js

@@ -4,12 +4,18 @@ import {
   RedstoneOptions
 } from "./market/pricefeeds/updates/index.js";
 import { ZodAddress } from "./utils/index.js";
-const OnchainSDKOptionsSchema = z.object({
-  /** When `true`, throw on unrecognised contract types. */
+const onchainSDKOptionsSchema = z.object({
+  /**
+   * When `true`, throw on unrecognised contract types.
+   **/
   strictContractTypes: z.boolean().optional(),
-  /** Plugins that extend SDK functionality. */
+  /**
+   * Plugins that extend SDK functionality.
+   **/
   plugins: z.record(z.string(), z.any()).optional(),
-  /** Custom logger implementation. */
+  /**
+   * Custom logger implementation.
+   **/
   logger: z.any(),
   /**
    * Explicit gas limit for read-only `eth_call` requests.
@@ -18,10 +24,14 @@ const OnchainSDKOptionsSchema = z.object({
    **/
   gasLimit: z.bigint().nonnegative().nullable().optional()
 });
-const AttachOptionsSchema = z.object({
-  /** Override address of the Gearbox AddressProvider contract. */
+const attachOptionsSchema = z.object({
+  /**
+   * Override address of the Gearbox AddressProvider contract.
+   **/
   addressProvider: ZodAddress().optional(),
-  /** Addresses of market configurator contracts to load. */
+  /**
+   * Addresses of market configurator contracts to load.
+   **/
   marketConfigurators: z.array(ZodAddress()).optional(),
   /**
    * Addresses of RWA factory contracts to load.
@@ -29,18 +39,32 @@ const AttachOptionsSchema = z.object({
    * (from {@link GearboxChain.rwaFactories})
    **/
   rwaFactories: z.array(ZodAddress()).optional(),
-  /** Pin SDK to a specific block number during attach. */
+  /**
+   * Pin SDK to a specific block number during attach.
+   **/
   blockNumber: z.union([z.bigint().nonnegative(), z.number().int().nonnegative()]).optional(),
-  /** Skip fetching updatable price feeds on attach and sync. */
+  /**
+   * Skip fetching updatable price feeds on attach and sync.
+   **/
   ignoreUpdateablePrices: z.boolean().optional(),
-  /** Pool addresses whose markets should be skipped. */
+  /**
+   * Pool addresses whose markets should be skipped.
+   **/
   ignoreMarkets: z.array(ZodAddress()).optional(),
-  /** Options for Redstone price-feed updates. */
+  /**
+   * Options for Redstone price-feed updates.
+   **/
   redstone: RedstoneOptions.optional(),
-  /** Options for Pyth price-feed updates. */
-  pyth: PythOptions.optional()
+  /**
+   * Options for Pyth price-feed updates.
+   **/
+  pyth: PythOptions.optional(),
+  /**
+   * When `true`, automatically load zappers during attach.
+   **/
+  loadZappers: z.boolean().optional()
 });
 export {
-  AttachOptionsSchema,
-  OnchainSDKOptionsSchema
+  attachOptionsSchema,
+  onchainSDKOptionsSchema
 };

package/dist/esm/sdk/router/AbstractRouterContract.js

@@ -1,6 +1,8 @@
-import { BaseContract } from "../base/index.js";
+import {
+  BaseContract
+} from "../base/index.js";
 import { PERCENTAGE_FACTOR } from "../constants/math.js";
-import { AddressMap, AddressSet, formatBN, isDust } from "../utils/index.js";
+import { AddressSet, AssetsMap, formatBN, isDust } from "../utils/index.js";
 import { limitLeftover } from "./helpers.js";
 class AbstractRouterContract extends BaseContract {
   /**
@@ -18,15 +20,15 @@ class AbstractRouterContract extends BaseContract {
       options.debtOnly
     );
     const { leftoverBalances, expectedBalances, tokensToClaim } = b;
-    const expected = new AddressMap();
-    const leftover = new AddressMap();
+    const expected = new AssetsMap();
+    const leftover = new AssetsMap();
     for (const token of cm.collateralTokens) {
-      const actual = expectedBalances.get(token)?.balance || 0n;
-      expected.upsert(token, { token, balance: actual > 10n ? actual : 0n });
-      leftover.upsert(token, {
+      const actual = expectedBalances.get(token) || 0n;
+      expected.upsert(token, actual > 10n ? actual : 0n);
+      leftover.upsert(
         token,
-        balance: limitLeftover(leftoverBalances.get(token)?.balance || 1n, token) ?? 1n
-      });
+        limitLeftover(leftoverBalances.get(token) || 1n, token) ?? 1n
+      );
     }
     return {
       expectedBalances: expected,
@@ -35,8 +37,8 @@ class AbstractRouterContract extends BaseContract {
     };
   }
   getDefaultExpectedAndLeftover(ca, keepAssets, debtOnly) {
-    const expectedBalances = new AddressMap();
-    const leftoverBalances = new AddressMap();
+    const expectedBalances = new AssetsMap();
+    const leftoverBalances = new AssetsMap();
     const keepAssetsSet = new AddressSet(keepAssets);
     if (debtOnly) {
       const result = this.getLeftoversAfterBuyingDebt(ca, keepAssetsSet);
@@ -48,23 +50,23 @@ class AbstractRouterContract extends BaseContract {
     }
     for (const { token, balance, mask } of ca.tokens) {
       const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
-      expectedBalances.upsert(token, { token, balance });
+      expectedBalances.upsert(token, balance);
       if (keepAssetsSet.has(token) || !isEnabled || isDust({
         sdk: this.sdk,
         token,
         balance,
         creditManager: ca.creditManager
       })) {
-        leftoverBalances.upsert(token, {
+        leftoverBalances.upsert(
           token,
-          balance: limitLeftover(balance, token) ?? balance
-        });
+          limitLeftover(balance, token) ?? balance
+        );
       }
     }
     return {
       expectedBalances,
       leftoverBalances,
-      tokensToClaim: new AddressMap()
+      tokensToClaim: new AssetsMap()
     };
   }
   /**
@@ -77,16 +79,13 @@ class AbstractRouterContract extends BaseContract {
     const { priceOracle } = this.sdk.marketRegister.findByCreditManager(
       ca.creditManager
     );
-    const expectedBalances = new AddressMap();
-    const leftoverBalances = new AddressMap();
+    const expectedBalances = new AssetsMap();
+    const leftoverBalances = new AssetsMap();
     const usdBalances = [];
     for (const { token, balance, mask } of ca.tokens) {
       const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
-      expectedBalances.upsert(token, { token, balance });
-      leftoverBalances.upsert(token, {
-        token,
-        balance: limitLeftover(balance, token) ?? balance
-      });
+      expectedBalances.upsert(token, balance);
+      leftoverBalances.upsert(token, limitLeftover(balance, token) ?? balance);
       if (isEnabled && !keepAssets.has(token)) {
         usdBalances.push({
           token,
@@ -116,15 +115,12 @@ class AbstractRouterContract extends BaseContract {
     if (tokenAmount === 0n) {
       return void 0;
     }
-    let leftoverBalance = leftoverBalances.get(highestToken.token)?.balance ?? 0n;
+    let leftoverBalance = leftoverBalances.get(highestToken.token) ?? 0n;
     leftoverBalance -= tokenAmount;
     if (leftoverBalance < 0n) {
       return void 0;
     }
-    leftoverBalances.upsert(highestToken.token, {
-      token: highestToken.token,
-      balance: leftoverBalance
-    });
+    leftoverBalances.upsert(highestToken.token, leftoverBalance);
     const tokenAmountStr = this.sdk.tokensMeta.formatBN(
       highestToken.token,
       tokenAmount,
@@ -137,7 +133,7 @@ class AbstractRouterContract extends BaseContract {
     return {
       expectedBalances,
       leftoverBalances,
-      tokensToClaim: new AddressMap()
+      tokensToClaim: new AssetsMap()
     };
   }
   safeConvertToUSD(priceOracle, token, balance) {

package/dist/esm/sdk/router/RouterV310Contract.js

@@ -1,10 +1,9 @@
 import { getAddress } from "viem";
 import { gearboxRouterAbi } from "../../abi/router/gearboxRouter.js";
-import { AddressMap } from "../utils/AddressMap.js";
 import { formatBN } from "../utils/formatter.js";
-import { isDust } from "../utils/index.js";
+import { AddressMap, AssetsMap, isDust } from "../utils/index.js";
 import { AbstractRouterContract } from "./AbstractRouterContract.js";
-import { assetsMap, balancesMap, limitLeftover } from "./helpers.js";
+import { limitLeftover } from "./helpers.js";
 const abi = gearboxRouterAbi;
 class RouterV310Contract extends AbstractRouterContract {
   #numSplits = new AddressMap();
@@ -71,8 +70,8 @@ class RouterV310Contract extends AbstractRouterContract {
       slippage
     } = props;
     const [expectedMap, leftoverMap] = [
-      balancesMap(expectedBalances),
-      balancesMap(leftoverBalances)
+      new AssetsMap(expectedBalances),
+      new AssetsMap(leftoverBalances)
     ];
     const getNumSplits = this.#numSplitsGetter(cm, expectedBalances);
     const tData = cm.collateralTokens.map(
@@ -157,22 +156,22 @@ class RouterV310Contract extends AbstractRouterContract {
     } = props;
     const { expectedBalances, leftoverBalances, tokensToClaim } = this.getExpectedAndLeftover(ca, cm, {
       balances: balances ? {
-        expectedBalances: assetsMap(balances.expectedBalances),
-        leftoverBalances: assetsMap(balances.leftoverBalances),
-        tokensToClaim: assetsMap(balances.tokensToClaim || [])
+        expectedBalances: new AssetsMap(balances.expectedBalances),
+        leftoverBalances: new AssetsMap(balances.leftoverBalances),
+        tokensToClaim: new AssetsMap(balances.tokensToClaim || [])
       } : void 0,
       keepAssets: balances ? void 0 : keepAssets,
       debtOnly
     });
-    const getNumSplits = this.#numSplitsGetter(cm, expectedBalances.values());
+    const getNumSplits = this.#numSplitsGetter(cm, expectedBalances.toAssets());
     const tData = [];
     for (const token of cm.collateralTokens) {
       tData.push({
         token,
-        balance: expectedBalances.get(token)?.balance || 0n,
-        leftoverBalance: limitLeftover(leftoverBalances.get(token)?.balance, token) ?? 0n,
+        balance: expectedBalances.get(token) || 0n,
+        leftoverBalance: limitLeftover(leftoverBalances.get(token), token) ?? 0n,
         numSplits: getNumSplits(token),
-        claimRewards: !!tokensToClaim.get(token)
+        claimRewards: tokensToClaim.has(token)
       });
     }
     this.logger?.debug(

package/dist/esm/sdk/router/helpers.js

@@ -1,7 +1,4 @@
 import { AddressMap } from "../utils/index.js";
-function balancesMap(assets) {
-  return new AddressMap(assets.map(({ token, balance }) => [token, balance]));
-}
 function assetsMap(assets) {
   return new AddressMap(assets.map((a) => [a.token, a]));
 }
@@ -16,6 +13,5 @@ function limitLeftover(balance, token) {
 }
 export {
   assetsMap,
-  balancesMap,
   limitLeftover
 };

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

@@ -113,6 +113,12 @@ class AddressMap {
   keys() {
     return Array.from(this.#map.keys());
   }
+  /**
+   * Returns an unfrozen shallow copy of the map.
+   **/
+  clone() {
+    return new AddressMap(this.entries(), this.name);
+  }
   /**
    * Converts the map to a plain `Record<Address, T>` object.
    **/

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

@@ -0,0 +1,38 @@
+import { AddressMap } from "./AddressMap.js";
+class AssetsMap extends AddressMap {
+  /**
+   * @param entries - Optional initial entries as `[address, balance]` tuples or {@link Asset} objects.
+   * @param name - Optional label used in error messages when a lookup fails.
+   */
+  constructor(entries, name) {
+    super(
+      entries?.map((e) => Array.isArray(e) ? e : [e.token, e.balance]),
+      name
+    );
+  }
+  /**
+   * Adds `amount` to the token balance, treating a missing key as `0n`.
+   */
+  inc(address, amount) {
+    this.upsert(address, (this.get(address) ?? 0n) + amount);
+  }
+  /**
+   * Subtracts `amount` from the token balance, treating a missing key as `0n`.
+   */
+  dec(address, amount) {
+    this.inc(address, -amount);
+  }
+  /**
+   * Converts the map to an array of {@link Asset} objects.
+   * @param filterDust - If true, filters out assets with a balance less than 1.
+   */
+  toAssets(filterDust = false) {
+    return this.entries().filter(filterDust ? ([, balance]) => balance > 1n : () => true).map(([token, balance]) => ({ token, balance }));
+  }
+  clone() {
+    return new AssetsMap(this.entries(), this.name);
+  }
+}
+export {
+  AssetsMap
+};

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

@@ -1,5 +1,6 @@
 export * from "./AddressMap.js";
 export * from "./AddressSet.js";
+export * from "./AssetsMap.js";
 export * from "./abi-decode.js";
 export * from "./bytes32ToString.js";
 export * from "./childLogger.js";