@gearbox-protocol/sdk 14.12.0-next.1 → 14.12.0-next.2

package/dist/cjs/abi/iZapper.js

@@ -24,80 +24,118 @@ module.exports = __toCommonJS(iZapper_exports);
 const iZapperAbi = [
   {
     type: "function",
+    name: "contractType",
     inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
     name: "pool",
-    outputs: [{ name: "", internalType: "address", type: "address" }],
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "previewDeposit",
     inputs: [
-      { name: "tokenInAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
     ],
-    name: "previewDeposit",
     outputs: [
-      { name: "tokenOutAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "previewRedeem",
     inputs: [
-      { name: "tokenOutAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" }
     ],
-    name: "previewRedeem",
     outputs: [
-      { name: "tokenInAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "redeem",
     inputs: [
-      { name: "tokenOutAmount", internalType: "uint256", type: "uint256" },
-      { name: "receiver", internalType: "address", type: "address" }
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" }
     ],
-    name: "redeem",
     outputs: [
-      { name: "tokenInAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
     ],
     stateMutability: "nonpayable"
   },
   {
     type: "function",
+    name: "redeemWithPermit",
     inputs: [
-      { name: "tokenOutAmount", internalType: "uint256", type: "uint256" },
-      { name: "receiver", internalType: "address", type: "address" },
-      { name: "deadline", internalType: "uint256", type: "uint256" },
-      { name: "v", internalType: "uint8", type: "uint8" },
-      { name: "r", internalType: "bytes32", type: "bytes32" },
-      { name: "s", internalType: "bytes32", type: "bytes32" }
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" },
+      { name: "deadline", type: "uint256", internalType: "uint256" },
+      { name: "v", type: "uint8", internalType: "uint8" },
+      { name: "r", type: "bytes32", internalType: "bytes32" },
+      { name: "s", type: "bytes32", internalType: "bytes32" }
     ],
-    name: "redeemWithPermit",
     outputs: [
-      { name: "tokenInAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
     ],
     stateMutability: "nonpayable"
   },
   {
     type: "function",
+    name: "redeemWithPermitAllowed",
+    inputs: [
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" },
+      { name: "nonce", type: "uint256", internalType: "uint256" },
+      { name: "expiry", type: "uint256", internalType: "uint256" },
+      { name: "v", type: "uint8", internalType: "uint8" },
+      { name: "r", type: "bytes32", internalType: "bytes32" },
+      { name: "s", type: "bytes32", internalType: "bytes32" }
+    ],
+    outputs: [
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "serialize",
     inputs: [],
-    name: "tokenIn",
-    outputs: [{ name: "", internalType: "address", type: "address" }],
+    outputs: [{ name: "serializedData", type: "bytes", internalType: "bytes" }],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "tokenIn",
     inputs: [],
-    name: "tokenOut",
-    outputs: [{ name: "", internalType: "address", type: "address" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "tokenOut",
     inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
     name: "underlying",
-    outputs: [{ name: "", internalType: "address", type: "address" }],
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "version",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   }
 ];

package/dist/cjs/preview/parse/errors.js

@@ -19,9 +19,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var errors_exports = {};
 __export(errors_exports, {
   UnsupportedPoolFunctionError: () => UnsupportedPoolFunctionError,
-  UnsupportedTargetError: () => UnsupportedTargetError
+  UnsupportedTargetError: () => UnsupportedTargetError,
+  UnsupportedZapperFunctionError: () => import_sdk.UnsupportedZapperFunctionError
 });
 module.exports = __toCommonJS(errors_exports);
+var import_sdk = require("../../sdk/index.js");
 class UnsupportedTargetError extends Error {
   target;
   constructor(target) {
@@ -43,5 +45,6 @@ class UnsupportedPoolFunctionError extends Error {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   UnsupportedPoolFunctionError,
-  UnsupportedTargetError
+  UnsupportedTargetError,
+  UnsupportedZapperFunctionError
 });

package/dist/cjs/preview/parse/parseOperationCalldata.js

@@ -26,11 +26,40 @@ var import_errors = require("./errors.js");
 var import_parseFacadeOperationCalldata = require("./parseFacadeOperationCalldata.js");
 var import_parsePoolOperationCalldata = require("./parsePoolOperationCalldata.js");
 function parseOperationCalldata(input) {
-  const { sdk, to, calldata } = input;
+  const { sdk, to, calldata, value, sender } = input;
   const contract = sdk.getContract(to);
   if (contract instanceof import_sdk.PoolV310Contract) {
     return (0, import_parsePoolOperationCalldata.parsePoolOperationCalldata)({ sdk, pool: contract, calldata });
   }
+  if (contract instanceof import_sdk.ZapperContract) {
+    const parsed = contract.parseOperation(calldata, value);
+    if (parsed.operation === "Deposit") {
+      const op2 = {
+        operation: "Deposit",
+        pool: parsed.pool,
+        receiver: parsed.receiver,
+        assets: parsed.assets,
+        underlying: parsed.underlying,
+        tokenIn: parsed.token,
+        zapper: parsed.zapper,
+        referralCode: parsed.referralCode
+      };
+      return op2;
+    }
+    const op = {
+      operation: "Redeem",
+      pool: parsed.pool,
+      receiver: parsed.receiver,
+      // The zapper burns the caller's pool shares, so the share owner is the
+      // transaction sender.
+      owner: sender,
+      shares: parsed.shares,
+      underlying: parsed.underlying,
+      tokenOut: parsed.token,
+      zapper: parsed.zapper
+    };
+    return op;
+  }
   if (contract instanceof import_sdk.CreditFacadeV310Contract) {
     return (0, import_parseFacadeOperationCalldata.parseFacadeOperationCalldata)({
       sdk,

package/dist/cjs/preview/parse/parsePoolOperationCalldata.js

@@ -37,6 +37,8 @@ function parsePoolOperationCalldata(props) {
         receiver: rawArgs.receiver,
         assets: rawArgs.assets,
         underlying,
+        tokenIn: underlying,
+        zapper: void 0,
         referralCode: functionName === "depositWithReferral" ? rawArgs.referralCode : void 0
       };
     case "mint":
@@ -47,6 +49,8 @@ function parsePoolOperationCalldata(props) {
         receiver: rawArgs.receiver,
         shares: rawArgs.shares,
         underlying,
+        tokenIn: underlying,
+        zapper: void 0,
         referralCode: functionName === "mintWithReferral" ? rawArgs.referralCode : void 0
       };
     case "withdraw":
@@ -56,7 +60,9 @@ function parsePoolOperationCalldata(props) {
         receiver: rawArgs.receiver,
         owner: rawArgs.owner,
         assets: rawArgs.assets,
-        underlying
+        underlying,
+        tokenOut: underlying,
+        zapper: void 0
       };
     case "redeem":
       return {
@@ -65,7 +71,9 @@ function parsePoolOperationCalldata(props) {
         receiver: rawArgs.receiver,
         owner: rawArgs.owner,
         shares: rawArgs.shares,
-        underlying
+        underlying,
+        tokenOut: underlying,
+        zapper: void 0
       };
     default:
       throw new import_errors.UnsupportedPoolFunctionError(pool.address, parsed.functionName);

package/dist/cjs/preview/prerequisites/buildPrerequisites.js

@@ -34,6 +34,23 @@ function buildPrerequisites(tx, ctx) {
     // here we approximate Mint by its shares amount (a lower bound on assets is
     // not knowable from calldata alone).
     case "Deposit":
+      if (tx.zapper) {
+        return [
+          new import_AllowancePrerequisite.AllowancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            spender: tx.zapper,
+            required: tx.assets,
+            title: "Token approved to zapper"
+          }),
+          new import_BalancePrerequisite.BalancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            required: tx.assets,
+            title: "Sufficient token balance"
+          })
+        ];
+      }
       return [
         new import_AllowancePrerequisite.AllowancePrerequisite({
           token: tx.underlying,
@@ -68,6 +85,23 @@ function buildPrerequisites(tx, ctx) {
     // Redeem and Withdraw both burn LP shares from `owner`; they only differ in
     // which side (shares vs assets) the caller specifies.
     case "Redeem": {
+      if (tx.zapper) {
+        return [
+          new import_BalancePrerequisite.BalancePrerequisite({
+            token: tx.pool,
+            owner: wallet,
+            required: tx.shares,
+            title: "Sufficient LP token balance"
+          }),
+          new import_AllowancePrerequisite.AllowancePrerequisite({
+            token: tx.pool,
+            owner: wallet,
+            spender: tx.zapper,
+            required: tx.shares,
+            title: "LP token approved to zapper"
+          })
+        ];
+      }
       const prereqs = [
         new import_BalancePrerequisite.BalancePrerequisite({
           token: tx.pool,

package/dist/cjs/preview/simulate/errors.js

@@ -20,7 +20,6 @@ var errors_exports = {};
 __export(errors_exports, {
   PreviewSimulationError: () => PreviewSimulationError,
   asPreviewSimulationError: () => asPreviewSimulationError,
-  combinePreviewSimulationErrors: () => combinePreviewSimulationErrors,
   decodeSimulationError: () => decodeSimulationError
 });
 module.exports = __toCommonJS(errors_exports);
@@ -49,11 +48,6 @@ function asPreviewSimulationError(reason, source) {
     { source, detail: decodeSimulationError({ error }) }
   ]);
 }
-function combinePreviewSimulationErrors(...errors) {
-  return new PreviewSimulationError(
-    errors.filter((e) => e).flatMap((e) => e?.failures ?? [])
-  );
-}
 function decodeSimulationError(revert) {
   const { error, data } = revert;
   if (data && data !== "0x") {
@@ -93,6 +87,5 @@ function formatDecodedError(errorName, args) {
 0 && (module.exports = {
   PreviewSimulationError,
   asPreviewSimulationError,
-  combinePreviewSimulationErrors,
   decodeSimulationError
 });

package/dist/cjs/preview/simulate/index.js

@@ -18,21 +18,18 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var simulate_exports = {};
 __export(simulate_exports, {
-  ETH_SIMULATE_V1_NETWORKS: () => import_constants.ETH_SIMULATE_V1_NETWORKS,
   PreviewSimulationError: () => import_errors.PreviewSimulationError,
   simulateFacadeOperation: () => import_simulateFacadeOperation.simulateFacadeOperation,
   simulateOperation: () => import_simulateOperation.simulateOperation,
   simulatePoolOperation: () => import_simulatePoolOperation.simulatePoolOperation
 });
 module.exports = __toCommonJS(simulate_exports);
-var import_constants = require("./constants.js");
 var import_errors = require("./errors.js");
 var import_simulateFacadeOperation = require("./simulateFacadeOperation.js");
 var import_simulateOperation = require("./simulateOperation.js");
 var import_simulatePoolOperation = require("./simulatePoolOperation.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ETH_SIMULATE_V1_NETWORKS,
   PreviewSimulationError,
   simulateFacadeOperation,
   simulateOperation,

package/dist/cjs/preview/simulate/simulatePoolOperation.js

@@ -18,45 +18,170 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var simulatePoolOperation_exports = {};
 __export(simulatePoolOperation_exports, {
+  computePoolOpBalanceChanges: () => computePoolOpBalanceChanges,
   simulatePoolOperation: () => simulatePoolOperation
 });
 module.exports = __toCommonJS(simulatePoolOperation_exports);
-var import_constants = require("./constants.js");
+var import_generated = require("../../abi/310/generated.js");
+var import_iERC20 = require("../../abi/iERC20.js");
+var import_iZapper = require("../../abi/iZapper.js");
+var import_sdk = require("../../sdk/index.js");
 var import_errors = require("./errors.js");
-var import_simulatePoolOpMulticall = require("./simulatePoolOpMulticall.js");
-var import_simulatePoolOpV1 = require("./simulatePoolOpV1.js");
+var import_holders = require("./holders.js");
+function previewRead(operation) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { functionName: "previewDeposit", amount: operation.assets };
+    case "Mint":
+      return { functionName: "previewMint", amount: operation.shares };
+    case "Withdraw":
+      return { functionName: "previewWithdraw", amount: operation.assets };
+    case "Redeem":
+      return { functionName: "previewRedeem", amount: operation.shares };
+  }
+}
+function outsideToken(operation) {
+  switch (operation.operation) {
+    case "Deposit":
+    case "Mint":
+      return operation.tokenIn;
+    case "Withdraw":
+    case "Redeem":
+      return operation.tokenOut;
+  }
+}
+function previewContract(operation) {
+  const { functionName, amount } = previewRead(operation);
+  if (operation.zapper) {
+    return {
+      address: operation.zapper,
+      abi: import_iZapper.iZapperAbi,
+      functionName,
+      args: [amount]
+    };
+  }
+  return {
+    address: operation.pool,
+    abi: import_generated.iPoolV310Abi,
+    functionName,
+    args: [amount]
+  };
+}
 async function simulatePoolOperation(input, options = {}) {
-  const { sdk } = input;
-  const { logger } = options;
-  const useSimulateV1 = options.useSimulateV1 ?? import_constants.ETH_SIMULATE_V1_NETWORKS.has(sdk.networkType);
-  logger?.debug(
-    { wallet: input.wallet, to: input.to },
-    "simulating pool operation"
-  );
-  const [v1, multicall] = await Promise.allSettled([
-    useSimulateV1 ? (0, import_simulatePoolOpV1.simulatePoolOpV1)(input, options) : void 0,
-    (0, import_simulatePoolOpMulticall.simulatePoolOpMulticall)(input, options)
-  ]);
-  if (v1.status === "fulfilled" && v1.value) {
-    return { status: "success", ...v1.value };
+  const { sdk, operation, wallet } = input;
+  const { blockNumber, logger } = options;
+  const { pool } = operation;
+  try {
+    const holders = (0, import_holders.watchedHolders)(operation, wallet);
+    const tokens = [outsideToken(operation), pool];
+    const balanceCalls = holders.flatMap(
+      (holder) => tokens.map((token) => ({ holder, token }))
+    );
+    const balanceContracts = balanceCalls.map(
+      ({ holder, token }) => ({
+        address: token,
+        abi: import_iERC20.ierc20Abi,
+        functionName: "balanceOf",
+        args: [holder]
+      })
+    );
+    const preview = previewContract(operation);
+    let results;
+    try {
+      results = await sdk.client.multicall({
+        allowFailure: false,
+        // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+        // testnet forks pinned to a specific block.
+        blockNumber,
+        contracts: [...balanceContracts, preview]
+      });
+    } catch (cause) {
+      throw new import_errors.PreviewSimulationError([
+        {
+          source: "multicall",
+          detail: (0, import_errors.decodeSimulationError)({
+            error: cause instanceof Error ? cause : new Error(String(cause))
+          })
+        }
+      ]);
+    }
+    const previewAmount = results[balanceContracts.length];
+    const balances = new import_sdk.AddressMap();
+    for (const [i, { holder, token }] of balanceCalls.entries()) {
+      const tokenBalances = balances.get(holder) ?? new import_sdk.AddressMap();
+      tokenBalances.upsert(token, results[i]);
+      balances.upsert(holder, tokenBalances);
+    }
+    const before = (token, holder) => balances.get(holder)?.get(token) ?? 0n;
+    return {
+      status: "success",
+      balanceChanges: computePoolOpBalanceChanges(
+        operation,
+        wallet,
+        previewAmount,
+        before
+      )
+    };
+  } catch (cause) {
+    const error = (0, import_errors.asPreviewSimulationError)(cause, "multicall");
+    logger?.error(error, "pool operation simulation failed");
+    return { status: "failure", error };
   }
-  if (multicall.status === "fulfilled") {
-    if (v1.status === "rejected") {
-      logger?.debug(
-        (0, import_errors.asPreviewSimulationError)(v1.reason, "eth_simulateV1"),
-        "eth_simulateV1 flow failed; falling back to multicall result"
-      );
+}
+function balanceLegs(operation, wallet, previewAmount) {
+  const { pool, receiver } = operation;
+  switch (operation.operation) {
+    case "Deposit":
+      return [
+        { address: wallet, token: operation.tokenIn, delta: -operation.assets },
+        { address: receiver, token: pool, delta: previewAmount }
+      ];
+    case "Mint":
+      return [
+        { address: wallet, token: operation.tokenIn, delta: -previewAmount },
+        { address: receiver, token: pool, delta: operation.shares }
+      ];
+    case "Withdraw":
+      return [
+        { address: operation.owner, token: pool, delta: -previewAmount },
+        {
+          address: receiver,
+          token: operation.tokenOut,
+          delta: operation.assets
+        }
+      ];
+    case "Redeem":
+      return [
+        { address: operation.owner, token: pool, delta: -operation.shares },
+        { address: receiver, token: operation.tokenOut, delta: previewAmount }
+      ];
+  }
+}
+function computePoolOpBalanceChanges(operation, wallet, previewAmount, before) {
+  const byAddress = new import_sdk.AddressMap();
+  for (const { address, token, delta } of balanceLegs(
+    operation,
+    wallet,
+    previewAmount
+  )) {
+    const beforeBalance = before(token, address);
+    const change = {
+      token,
+      before: beforeBalance,
+      after: beforeBalance + delta,
+      delta
+    };
+    const existing = byAddress.get(address);
+    if (existing) {
+      existing.changes.push(change);
+    } else {
+      byAddress.upsert(address, { address, changes: [change] });
     }
-    return { status: "success", ...multicall.value };
   }
-  const error = (0, import_errors.combinePreviewSimulationErrors)(
-    v1.status === "rejected" ? (0, import_errors.asPreviewSimulationError)(v1.reason, "eth_simulateV1") : void 0,
-    (0, import_errors.asPreviewSimulationError)(multicall.reason, "multicall")
-  );
-  logger?.error(error, "pool operation simulation failed");
-  return { status: "failure", error };
+  return byAddress.values();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  computePoolOpBalanceChanges,
   simulatePoolOperation
 });

package/dist/cjs/sdk/MultichainSDK.js

@@ -81,6 +81,7 @@ class MultichainSDK {
         const perChainOpts = options?.perChain?.[network] ?? {};
         return sdk.attach({
           ...perChainOpts,
+          loadZappers: perChainOpts.loadZappers ?? options?.loadZappers,
           redstone: {
             ...options?.redstone,
             cache: this.#redstoneCache,

package/dist/cjs/sdk/OnchainSDK.js

@@ -127,7 +127,8 @@ class OnchainSDK extends import_base.ChainContractsRegister {
       ignoreMarkets,
       marketConfigurators: mcs,
       redstone,
-      pyth
+      pyth,
+      loadZappers
     } = options ?? {};
     const marketConfigurators = mcs ?? import_utils.TypedObjectUtils.keys(
       this.client.chain.defaultMarketConfigurators
@@ -196,6 +197,9 @@ class OnchainSDK extends import_base.ChainContractsRegister {
         blockNumber: this.currentBlock,
         gas: this.gasLimit
       });
+      if (loadZappers) {
+        await this.#marketRegister.loadZappers();
+      }
     }
     const pluginsList = import_utils.TypedObjectUtils.entries(this.plugins);
     const pluginResponse = await Promise.allSettled(
@@ -248,7 +252,7 @@ class OnchainSDK extends import_base.ChainContractsRegister {
       `address provider version: ${this.#addressProvider.version}`
     );
     this.#marketRegister = new import_MarketRegister.MarketRegister(this, ignoreMarkets);
-    this.#marketRegister.hydrate(state.markets);
+    this.#marketRegister.hydrate(state);
     this.#rwa = new import_market.RWARegistry(this);
     this.#rwa.setState(state.rwa);
     for (const [name, plugin] of import_utils.TypedObjectUtils.entries(this.plugins)) {
@@ -313,7 +317,7 @@ class OnchainSDK extends import_base.ChainContractsRegister {
       currentBlock: this.currentBlock,
       timestamp: this.timestamp,
       addressProvider: this.addressProvider.state,
-      markets: this.marketRegister.state,
+      ...this.marketRegister.state,
       rwa: this.#rwa.state,
       plugins: Object.fromEntries(
         import_utils.TypedObjectUtils.entries(this.plugins).map(([name, plugin]) => [

package/dist/cjs/sdk/market/MarketRegister.js

@@ -52,10 +52,11 @@ class MarketRegister extends import_ZapperRegister.ZapperRegister {
    * bypassing on-chain reads.
    * @param state - Array of market data snapshots.
    **/
-  hydrate(state) {
-    const configurators = new Set(state.map((m) => m.configurator));
+  hydrate({ markets, zappers }) {
+    const configurators = new Set(markets.map((m) => m.configurator));
     this.#setMarketFilter([...configurators]);
-    this.#setMarkets(state);
+    this.#setMarkets(markets);
+    this.hydrateZappers(zappers);
   }
   /**
    * @internal
@@ -174,7 +175,10 @@ class MarketRegister extends import_ZapperRegister.ZapperRegister {
    * Serializable snapshot of all loaded markets, suitable for hydration.
    **/
   get state() {
-    return this.markets.map((market) => market.state);
+    return {
+      markets: this.markets.map((market) => market.state),
+      zappers: this.zappersState
+    };
   }
   /**
    * Returns a human-readable snapshot of all markets.
@@ -182,7 +186,8 @@ class MarketRegister extends import_ZapperRegister.ZapperRegister {
    **/
   stateHuman(raw = true) {
     return {
-      markets: this.markets.map((market) => market.stateHuman(raw))
+      markets: this.markets.map((market) => market.stateHuman(raw)),
+      zappers: this.zappersStateHuman(raw)
     };
   }
   /**