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

package/dist/cjs/preview/preview/previewPoolOperation.js

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var previewPoolOperation_exports = {};
+__export(previewPoolOperation_exports, {
+  previewPoolOperation: () => previewPoolOperation
+});
+module.exports = __toCommonJS(previewPoolOperation_exports);
+var import_simulate = require("../simulate/index.js");
+async function previewPoolOperation(input, operation, options) {
+  const { sdk, to, calldata } = input;
+  const { tokenIn, tokenOut } = operation;
+  const sim = await (0, import_simulate.simulatePoolOperation)(
+    { sdk, operation, to, calldata },
+    options
+  );
+  if (sim.status === "success") {
+    return {
+      operation: operation.operation,
+      pool: operation.pool,
+      tokenIn: { token: tokenIn, balance: sim.amountIn },
+      tokenOut: { token: tokenOut, balance: sim.amountOut }
+    };
+  }
+  const { error } = sim;
+  switch (operation.operation) {
+    case "Deposit":
+      return {
+        operation: "Deposit",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, balance: operation.assets },
+        tokenOut: { token: tokenOut, error }
+      };
+    case "Mint":
+      return {
+        operation: "Mint",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, error },
+        tokenOut: { token: tokenOut, balance: operation.shares }
+      };
+    case "Withdraw":
+      return {
+        operation: "Withdraw",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, error },
+        tokenOut: { token: tokenOut, balance: operation.assets }
+      };
+    case "Redeem":
+      return {
+        operation: "Redeem",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, balance: operation.shares },
+        tokenOut: { token: tokenOut, error }
+      };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  previewPoolOperation
+});

package/dist/cjs/preview/preview/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/{sdk/market/zapper/Zapper.js → preview/preview/unwrapNativeCollateral.js}

@@ -16,32 +16,30 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Zapper_exports = {};
-__export(Zapper_exports, {
-  Zapper: () => Zapper
+var unwrapNativeCollateral_exports = {};
+__export(unwrapNativeCollateral_exports, {
+  unwrapNativeCollateral: () => unwrapNativeCollateral
 });
-module.exports = __toCommonJS(Zapper_exports);
-var import_utils = require("../../utils/index.js");
-class Zapper {
-  pool;
-  type;
-  baseParams;
-  tokenIn;
-  tokenOut;
-  contractType;
-  constructor(data) {
-    this.pool = data.pool;
-    this.type = data.type;
-    this.baseParams = data.baseParams;
-    this.tokenIn = data.tokenIn;
-    this.tokenOut = data.tokenOut;
-    this.contractType = Zapper.contractType(data.baseParams);
+module.exports = __toCommonJS(unwrapNativeCollateral_exports);
+var import_sdk = require("../../sdk/index.js");
+var import_errors = require("./errors.js");
+function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
+  if (nativeAmount === 0n) {
+    return collateral;
   }
-  static contractType(baseParams) {
-    return (0, import_utils.bytes32ToString)(baseParams.contractType);
+  const balances = new import_sdk.AssetsMap(collateral);
+  const wethBalance = balances.get(wethToken) ?? 0n;
+  if (wethBalance < nativeAmount) {
+    throw new import_errors.InvalidTransactionValueError(nativeAmount, wethBalance);
   }
+  balances.upsert(
+    wethToken,
+    wethBalance === nativeAmount ? void 0 : wethBalance - nativeAmount
+  );
+  balances.inc(import_sdk.NATIVE_ADDRESS, nativeAmount);
+  return balances.toAssets();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Zapper
+  unwrapNativeCollateral
 });

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,23 +18,23 @@ 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
+  simulatePoolOperation: () => import_simulatePoolOperation.simulatePoolOperation,
+  simulateRWAOperation: () => import_simulateRWAOperation.simulateRWAOperation
 });
 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");
+var import_simulateRWAOperation = require("./simulateRWAOperation.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ETH_SIMULATE_V1_NETWORKS,
   PreviewSimulationError,
   simulateFacadeOperation,
   simulateOperation,
-  simulatePoolOperation
+  simulatePoolOperation,
+  simulateRWAOperation
 });

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

@@ -24,11 +24,15 @@ module.exports = __toCommonJS(simulateOperation_exports);
 var import_parse = require("../parse/index.js");
 var import_simulateFacadeOperation = require("./simulateFacadeOperation.js");
 var import_simulatePoolOperation = require("./simulatePoolOperation.js");
+var import_simulateRWAOperation = require("./simulateRWAOperation.js");
 async function simulateOperation(input, options) {
   const { operation } = input;
   if ((0, import_parse.isPoolOperation)(operation)) {
     return (0, import_simulatePoolOperation.simulatePoolOperation)({ ...input, operation }, options);
   }
+  if ((0, import_parse.isRWAOperation)(operation)) {
+    return (0, import_simulateRWAOperation.simulateRWAOperation)({ ...input, operation }, options);
+  }
   return (0, import_simulateFacadeOperation.simulateFacadeOperation)({ ...input, operation }, options);
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -21,40 +21,69 @@ __export(simulatePoolOperation_exports, {
   simulatePoolOperation: () => simulatePoolOperation
 });
 module.exports = __toCommonJS(simulatePoolOperation_exports);
-var import_constants = require("./constants.js");
+var import_generated = require("../../abi/310/generated.js");
+var import_iZapper = require("../../abi/iZapper.js");
 var import_errors = require("./errors.js");
-var import_simulatePoolOpMulticall = require("./simulatePoolOpMulticall.js");
-var import_simulatePoolOpV1 = require("./simulatePoolOpV1.js");
-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 };
+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 previewContract(operation) {
+  const { functionName, amount } = previewRead(operation);
+  if (operation.zapper) {
+    return {
+      address: operation.zapper,
+      abi: import_iZapper.iZapperAbi,
+      functionName,
+      args: [amount]
+    };
   }
-  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"
-      );
-    }
-    return { status: "success", ...multicall.value };
+  return {
+    address: operation.pool,
+    abi: import_generated.iPoolV310Abi,
+    functionName,
+    args: [amount]
+  };
+}
+function amountsInOut(operation, previewAmount) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { amountIn: operation.assets, amountOut: previewAmount };
+    case "Mint":
+      return { amountIn: previewAmount, amountOut: operation.shares };
+    case "Withdraw":
+      return { amountIn: previewAmount, amountOut: operation.assets };
+    case "Redeem":
+      return { amountIn: operation.shares, amountOut: previewAmount };
+  }
+}
+async function simulatePoolOperation(input, options = {}) {
+  const { sdk, operation } = input;
+  const { blockNumber, logger } = options;
+  try {
+    const previewAmount = await sdk.client.readContract({
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber,
+      ...previewContract(operation)
+    });
+    return {
+      status: "success",
+      ...amountsInOut(operation, previewAmount)
+    };
+  } catch (cause) {
+    const error = (0, import_errors.asPreviewSimulationError)(cause, "multicall");
+    logger?.error(error, "pool operation simulation failed");
+    return { status: "failure", error };
   }
-  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 };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/preview/simulate/{constants.js → simulateRWAOperation.js}

@@ -16,13 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var constants_exports = {};
-__export(constants_exports, {
-  ETH_SIMULATE_V1_NETWORKS: () => ETH_SIMULATE_V1_NETWORKS
+var simulateRWAOperation_exports = {};
+__export(simulateRWAOperation_exports, {
+  simulateRWAOperation: () => simulateRWAOperation
 });
-module.exports = __toCommonJS(constants_exports);
-const ETH_SIMULATE_V1_NETWORKS = /* @__PURE__ */ new Set(["Mainnet", "Plasma", "Somnia"]);
+module.exports = __toCommonJS(simulateRWAOperation_exports);
+async function simulateRWAOperation(_input, _options) {
+  throw new Error("not yet implemented");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ETH_SIMULATE_V1_NETWORKS
+  simulateRWAOperation
 });

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/accounts/CreditAccountsServiceV310.js

@@ -36,7 +36,6 @@ var import_base = require("../base/index.js");
 var import_chains = require("../chain/chains.js");
 var import_constants = require("../constants/index.js");
 var import_market = require("../market/index.js");
-var import_router = require("../router/index.js");
 var import_utils = require("../utils/index.js");
 var import_viem2 = require("../utils/viem/index.js");
 var import_multicall_utils = require("./multicall-utils.js");
@@ -621,14 +620,12 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
       creditManager: cm.creditManager,
       slippage
     });
-    const operationCalls = [
-      ...routerCloseResult.calls,
-      ...this.#prepareDisableQuotas(ca),
-      ...this.#prepareDecreaseDebt(ca),
-      ...assetsToWithdraw.map(
-        (t) => this.#prepareWithdrawToken(ca.creditFacade, t, import_constants.MAX_UINT256, to)
-      )
-    ];
+    const operationCalls = await this.assembleCloseCreditAccountCalls({
+      creditAccount: ca,
+      routerCalls: routerCloseResult.calls,
+      assetsToWithdraw,
+      to
+    });
     const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
     const tx = await this.#closeCreditAccountTx(
       cm,
@@ -638,6 +635,32 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
     );
     return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
   }
+  /**
+   * {@inheritDoc ICreditAccountsService.assembleCloseCreditAccountCalls}
+   */
+  async assembleCloseCreditAccountCalls({
+    creditAccount: ca,
+    routerCalls,
+    assetsToWithdraw,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    await this.sdk.tokensMeta.loadTokenData(cm.underlying);
+    const underlying = this.sdk.tokensMeta.mustGet(cm.underlying);
+    if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) {
+      throw new Error(
+        "closeCreditAccount is not supported for RWA underlying credit accounts"
+      );
+    }
+    return [
+      ...routerCalls,
+      ...this.#prepareDisableQuotas(ca),
+      ...this.#prepareDecreaseDebt(ca),
+      ...assetsToWithdraw.map(
+        (t) => this.#prepareWithdrawToken(ca.creditFacade, t, import_constants.MAX_UINT256, to)
+      )
+    ];
+  }
   /**
    * {@inheritDoc ICreditAccountsService.updateQuotas}
    **/
@@ -1307,8 +1330,23 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
   /**
    * {@inheritDoc ICreditAccountsService.repayCreditAccount}
    */
-  async repayCreditAccount({
-    operation,
+  async repayCreditAccount(props) {
+    const { operation, creditAccount: ca } = props;
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const operationCalls = await this.assembleRepayCreditAccountCalls(props);
+    const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
+    const tx = await this.#closeCreditAccountTx(
+      cm,
+      ca.creditAccount,
+      calls,
+      operation
+    );
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.assembleRepayCreditAccountCalls}
+   */
+  async assembleRepayCreditAccountCalls({
     collateralAssets,
     assetsToWithdraw,
     creditAccount: ca,
@@ -1317,7 +1355,6 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
     tokensToClaim,
     calls: wrapCalls = []
   }) {
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
     const addCollateral = collateralAssets.filter((a) => a.balance > 0);
     const router = this.sdk.routerFor(ca);
     const unwrapCalls = await this.getRedeemDiffCalls(1n, ca.creditManager) ?? [];
@@ -1336,14 +1373,7 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
         (t) => this.#prepareWithdrawToken(ca.creditFacade, t.token, import_constants.MAX_UINT256, to)
       )
     ];
-    const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
-    const tx = await this.#closeCreditAccountTx(
-      cm,
-      ca.creditAccount,
-      calls,
-      operation
-    );
-    return { tx, calls, creditFacade: cm.creditFacade };
+    return operationCalls;
   }
   /**
    * {@inheritDoc ICreditAccountsService.repayAndLiquidateCreditAccount}
@@ -1723,10 +1753,10 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
     return calls;
   }
   #prepareUpdateQuotas(creditFacade, { averageQuota, minQuota }) {
-    const minRecord = (0, import_router.assetsMap)(minQuota);
+    const minRecord = new import_utils.AssetsMap(minQuota);
     const calls = averageQuota.map((q) => {
-      const minAsset = minRecord.get(q.token);
-      const min = minAsset && minAsset?.balance > 0 ? minAsset.balance : 0n;
+      const minBalance = minRecord.get(q.token);
+      const min = minBalance && minBalance > 0n ? minBalance : 0n;
       return {
         target: creditFacade,
         callData: (0, import_viem.encodeFunctionData)({

package/dist/cjs/sdk/base/BaseContract.js

@@ -244,6 +244,7 @@ class BaseContract extends import_Construct.Construct {
       const functionName = (0, import_utils.getFunctionSignature)(this.abi, calldata);
       return this.wrapParseCallV2(
         functionName,
+        calldata,
         this.parseFunctionParamsV2(decoded, strict)
       );
     } catch (e) {
@@ -257,7 +258,7 @@ class BaseContract extends import_Construct.Construct {
       this.logger?.warn(e);
       const selector = calldata.slice(0, 10);
       const data = `0x${calldata.slice(10)}`;
-      return this.wrapParseCallV2(`unknown function ${selector}`, {
+      return this.wrapParseCallV2(`unknown function ${selector}`, calldata, {
         _data: data
       });
     }
@@ -270,7 +271,7 @@ class BaseContract extends import_Construct.Construct {
   parseFunctionParamsV2(params, _strict) {
     return (0, import_utils.functionArgsToRecord)(this.abi, params.functionName, params.args);
   }
-  wrapParseCallV2(functionName, rawArgs) {
+  wrapParseCallV2(functionName, calldata, rawArgs) {
     return {
       chainId: this.chainId,
       target: this.address,
@@ -278,6 +279,7 @@ class BaseContract extends import_Construct.Construct {
       label: this.labelAddress(this.address, true),
       version: this.version,
       functionName,
+      calldata,
       rawArgs
     };
   }

package/dist/cjs/sdk/base/ChainContractsRegister.js

@@ -184,6 +184,7 @@ class ChainContractsRegister {
       label: this.labelAddress(address, true),
       version: 0,
       functionName: `unknown function ${selector}`,
+      calldata,
       rawArgs: { _data: data }
     };
   }

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)
     };
   }
   /**

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

@@ -75,6 +75,60 @@ class ZapperRegister extends import_base.SDKConstruct {
       }
     }
   }
+  /**
+   * Serializable snapshot of all loaded zappers, suitable for hydration.
+   * Returns `undefined` when zappers were never loaded (i.e. `loadZappers` was
+   * not called), so the not-loaded state round-trips cleanly.
+   **/
+  get zappersState() {
+    if (!this.#zappers) {
+      return void 0;
+    }
+    return this.#zappers.values().flatMap(
+      (zappers) => zappers.map((z) => ({
+        pool: z.pool,
+        type: z.type,
+        baseParams: z.baseParams,
+        tokenIn: z.tokenIn,
+        tokenOut: z.tokenOut
+      }))
+    );
+  }
+  /**
+   * Restores zapper state from a previously serialized snapshot,
+   * bypassing on-chain reads.
+   * @param state - Array of zapper data snapshots, or `undefined` when zappers
+   *   were not loaded in the snapshot (leaves the registry in the not-loaded state).
+   **/
+  hydrateZappers(state) {
+    if (!state) {
+      return;
+    }
+    this.#zappers = new import_utils.AddressMap(void 0, "zappers");
+    for (const z of state) {
+      this.#addZapper(z);
+    }
+  }
+  /**
+   * Returns a human-readable snapshot of all loaded zappers.
+   * Returns `undefined` when zappers were never loaded.
+   * @param raw - When `true`, includes raw/unformatted values.
+   **/
+  zappersStateHuman(_ = true) {
+    if (!this.#zappers) {
+      return void 0;
+    }
+    return this.#zappers.values().flatMap(
+      (zappers) => zappers.map((z) => ({
+        address: this.labelAddress(z.baseParams.addr),
+        contractType: z.contractType,
+        type: z.type,
+        pool: this.labelAddress(z.pool),
+        tokenIn: this.sdk.labelAddress(z.tokenIn.addr),
+        tokenOut: this.sdk.labelAddress(z.tokenOut.addr)
+      }))
+    );
+  }
   #addZapper(z) {
     const zapper = (0, import_zapper.createZapper)(this.sdk, z);
     const existing = this.zappers.get(z.pool);