@gearbox-protocol/sdk 14.12.0-next.4 → 14.12.0-next.41

package/dist/cjs/preview/preview/replayInnerOperations.js

@@ -0,0 +1,153 @@
+"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 replayInnerOperations_exports = {};
+__export(replayInnerOperations_exports, {
+  makeReplayState: () => makeReplayState,
+  replayInnerOperations: () => replayInnerOperations
+});
+module.exports = __toCommonJS(replayInnerOperations_exports);
+var import_adapters = require("../../plugins/adapters/index.js");
+var import_sdk = require("../../sdk/index.js");
+var import_applyRWAWrapUnwrap = require("./applyRWAWrapUnwrap.js");
+var import_types = require("./types.js");
+function makeReplayState(account) {
+  return {
+    account,
+    collateralAdded: new import_sdk.AssetsMap(),
+    collateralWithdrawn: new import_sdk.AssetsMap()
+  };
+}
+async function replayInnerOperations(sdk, multicall, state) {
+  let inBracket = false;
+  let error;
+  for (const op of multicall) {
+    let opError;
+    switch (op.operation) {
+      case "AddCollateral":
+        applyAddCollateral(state, op);
+        break;
+      case "WithdrawCollateral":
+        applyWithdrawCollateral(state, op);
+        break;
+      case "IncreaseBorrowedAmount":
+        state.account.increaseDebt(op.amount);
+        break;
+      case "DecreaseBorrowedAmount":
+        state.account.repay(op.amount);
+        break;
+      case "UpdateQuota":
+        state.account.updateQuota(op.token, op.change);
+        break;
+      case "StoreExpectedBalances":
+        if (inBracket) {
+          opError = {
+            code: import_types.ERROR_MALFORMED_BRACKET,
+            message: "nested storeExpectedBalances/compareBalances bracket"
+          };
+        }
+        inBracket = true;
+        for (const { token, balance } of op.deltas) {
+          state.account.balances.inc(token, balance);
+        }
+        break;
+      case "CompareBalances":
+        if (!inBracket) {
+          opError = {
+            code: import_types.ERROR_MALFORMED_BRACKET,
+            message: "compareBalances without a preceding storeExpectedBalances"
+          };
+        }
+        inBracket = false;
+        break;
+      case "Execute":
+        opError = await applyExecute(
+          sdk,
+          op,
+          inBracket,
+          state.account.balances
+        );
+        break;
+    }
+    error ??= opError;
+  }
+  if (inBracket) {
+    error ??= {
+      code: import_types.ERROR_MALFORMED_BRACKET,
+      message: "storeExpectedBalances without a matching compareBalances"
+    };
+  }
+  return error;
+}
+function applyAddCollateral(state, op) {
+  state.collateralAdded.inc(op.token, op.amount);
+  state.account.balances.inc(op.token, op.amount);
+}
+function applyWithdrawCollateral(state, op) {
+  const running = state.account.balances.getOrZero(op.token);
+  const amount = op.amount === import_sdk.MAX_UINT256 ? running > 0n ? running : 0n : op.amount;
+  state.account.balances.dec(op.token, amount);
+  state.collateralWithdrawn.inc(op.token, amount);
+}
+async function applyExecute(sdk, op, inBracket, balances) {
+  const adapter = sdk.getContract(op.adapter);
+  if (!inBracket) {
+    if (!isRWAShare(sdk, adapter)) {
+      return {
+        code: import_types.ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+        message: `call to ${op.adapter} outside of a storeExpectedBalances/compareBalances bracket`
+      };
+    }
+    try {
+      (0, import_applyRWAWrapUnwrap.applyRWAWrapUnwrap)(adapter, op.calldata, balances);
+      return void 0;
+    } catch (e) {
+      return {
+        code: import_types.ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+        message: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  if (!(adapter instanceof import_adapters.AbstractAdapterContract)) {
+    return {
+      code: import_types.ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+      message: `call to ${op.adapter} between storeExpectedBalances and compareBalances is not an adapter call`
+    };
+  }
+  try {
+    await adapter.previewBalanceChanges(balances, op.calldata);
+    return void 0;
+  } catch (e) {
+    return {
+      code: import_types.ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+      message: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function isRWAShare(sdk, adapter) {
+  if (adapter instanceof import_adapters.ERC4626AdapterContract) {
+    const meta = sdk.tokensMeta.get(adapter.share);
+    return !!meta && sdk.tokensMeta.isRWAUnderlying(meta);
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeReplayState,
+  replayInnerOperations
+});

package/dist/cjs/preview/preview/replayMulticall.js

@@ -0,0 +1,37 @@
+"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 replayMulticall_exports = {};
+__export(replayMulticall_exports, {
+  replayMulticall: () => replayMulticall
+});
+module.exports = __toCommonJS(replayMulticall_exports);
+var import_CreditAccountState = require("./CreditAccountState.js");
+var import_replayInnerOperations = require("./replayInnerOperations.js");
+async function replayMulticall(sdk, operation, options) {
+  const before = import_CreditAccountState.CreditAccountState.fromCreditAccountData(
+    options.creditAccount
+  );
+  const after = (0, import_replayInnerOperations.makeReplayState)(before.clone());
+  const error = await (0, import_replayInnerOperations.replayInnerOperations)(sdk, operation.multicall, after);
+  return { before, after, error };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  replayMulticall
+});

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

@@ -0,0 +1,49 @@
+"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 types_exports = {};
+__export(types_exports, {
+  ERROR_ADAPTER_CALL_OUTSIDE_BRACKET: () => ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+  ERROR_INVALID_TRANSACTION_VALUE: () => ERROR_INVALID_TRANSACTION_VALUE,
+  ERROR_MALFORMED_BRACKET: () => ERROR_MALFORMED_BRACKET,
+  ERROR_NON_ADAPTER_CALL_IN_BRACKET: () => ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+  ERROR_UNPREVIEWABLE_ADAPTER_CALL: () => ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+  ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP: () => ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+  ERROR_UNPRICEABLE_TOKEN: () => ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST: () => PREVIEW_DUST
+});
+module.exports = __toCommonJS(types_exports);
+const ERROR_MALFORMED_BRACKET = 1001;
+const ERROR_ADAPTER_CALL_OUTSIDE_BRACKET = 1002;
+const ERROR_NON_ADAPTER_CALL_IN_BRACKET = 1003;
+const ERROR_UNPREVIEWABLE_ADAPTER_CALL = 1004;
+const ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP = 1005;
+const ERROR_INVALID_TRANSACTION_VALUE = 1006;
+const ERROR_UNPRICEABLE_TOKEN = 2001;
+const PREVIEW_DUST = 10n;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+  ERROR_INVALID_TRANSACTION_VALUE,
+  ERROR_MALFORMED_BRACKET,
+  ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+  ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+  ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+  ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST
+});

package/dist/cjs/preview/preview/unwrapNativeCollateral.js

@@ -0,0 +1,51 @@
+"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 unwrapNativeCollateral_exports = {};
+__export(unwrapNativeCollateral_exports, {
+  unwrapNativeCollateral: () => unwrapNativeCollateral
+});
+module.exports = __toCommonJS(unwrapNativeCollateral_exports);
+var import_sdk = require("../../sdk/index.js");
+var import_types = require("./types.js");
+function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
+  if (nativeAmount === 0n) {
+    return { assets: collateral };
+  }
+  const balances = new import_sdk.AssetsMap(collateral);
+  const wethBalance = balances.get(wethToken) ?? 0n;
+  if (wethBalance < nativeAmount) {
+    return {
+      assets: collateral,
+      error: {
+        code: import_types.ERROR_INVALID_TRANSACTION_VALUE,
+        message: `transaction value ${nativeAmount} exceeds WETH collateral ${wethBalance}`
+      }
+    };
+  }
+  balances.upsert(
+    wethToken,
+    wethBalance === nativeAmount ? void 0 : wethBalance - nativeAmount
+  );
+  balances.inc(import_sdk.NATIVE_ADDRESS, nativeAmount);
+  return { assets: balances.toAssets() };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  unwrapNativeCollateral
+});

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

@@ -18,16 +18,12 @@ 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_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_holders = require("./holders.js");
 function previewRead(operation) {
   switch (operation.operation) {
     case "Deposit":
@@ -40,16 +36,6 @@ function previewRead(operation) {
       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) {
@@ -67,121 +53,36 @@ function previewContract(operation) {
     args: [amount]
   };
 }
-async function simulatePoolOperation(input, options = {}) {
-  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 };
-  }
-}
-function balanceLegs(operation, wallet, previewAmount) {
-  const { pool, receiver } = operation;
+function amountsInOut(operation, previewAmount) {
   switch (operation.operation) {
     case "Deposit":
-      return [
-        { address: wallet, token: operation.tokenIn, delta: -operation.assets },
-        { address: receiver, token: pool, delta: previewAmount }
-      ];
+      return { amountIn: operation.assets, amountOut: previewAmount };
     case "Mint":
-      return [
-        { address: wallet, token: operation.tokenIn, delta: -previewAmount },
-        { address: receiver, token: pool, delta: operation.shares }
-      ];
+      return { amountIn: previewAmount, amountOut: operation.shares };
     case "Withdraw":
-      return [
-        { address: operation.owner, token: pool, delta: -previewAmount },
-        {
-          address: receiver,
-          token: operation.tokenOut,
-          delta: operation.assets
-        }
-      ];
+      return { amountIn: previewAmount, amountOut: operation.assets };
     case "Redeem":
-      return [
-        { address: operation.owner, token: pool, delta: -operation.shares },
-        { address: receiver, token: operation.tokenOut, delta: previewAmount }
-      ];
+      return { amountIn: operation.shares, amountOut: 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] });
-    }
+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 amountsInOut(operation, previewAmount);
+  } catch (cause) {
+    const error = (0, import_errors.asPreviewSimulationError)(cause, "multicall");
+    logger?.error(error, "pool operation simulation failed");
+    throw error;
   }
-  return byAddress.values();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  computePoolOpBalanceChanges,
   simulatePoolOperation
 });

package/dist/cjs/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/rewards/rewards/extra-apy.js

@@ -50,23 +50,27 @@ function getKeyForPoolPointsInfo(i) {
 class PoolPointsAPI {
   constructor() {
   }
+  static defaultBackendUrl = "https://api.gearbox.foundation";
   static async getTotalTokensOnProtocol({
     tokensToCheck,
     tokensList,
-    network
+    network,
+    backendUrl = PoolPointsAPI.defaultBackendUrl
   }) {
     const list = [...new Set(tokensToCheck)];
     const res = await Promise.allSettled(
-      list.map((t) => PoolPointsAPI.getTokenTotal(t, network, tokensList))
+      list.map(
+        (t) => PoolPointsAPI.getTokenTotal(t, network, tokensList, backendUrl)
+      )
     );
     return res.map((r, i) => [
       list[i],
       r
     ]);
   }
-  static async getTokenTotal(token, network, tokensList) {
+  static async getTokenTotal(token, network, tokensList, backendUrl) {
     const chainId = import_sdk.chains[network]?.id;
-    const url = `https://api.gearbox.foundation/v1/getBalanceAt?asset=${token}&chainId=${chainId}`;
+    const url = `${backendUrl}/v1/getBalanceAt?asset=${token}&chainId=${chainId}`;
     const result = await import_axios.default.get(url);
     const balance = result.data.result.reduce(
       (sum, r) => r.effective_balance + sum,

package/dist/cjs/sdk/MultichainSDK.js

@@ -21,6 +21,7 @@ __export(MultichainSDK_exports, {
   MultichainSDK: () => MultichainSDK
 });
 module.exports = __toCommonJS(MultichainSDK_exports);
+var import_accounts = require("./accounts/index.js");
 var import_chains = require("./chain/chains.js");
 var import_core = require("./core/index.js");
 var import_updates = require("./market/pricefeeds/updates/index.js");
@@ -30,6 +31,11 @@ class MultichainSDK {
   #redstoneCache;
   #pythCache;
   #logger;
+  /**
+   * Namespace for liquidatable credit accounts discovery across all
+   * configured chains.
+   */
+  liquidations;
   constructor(options) {
     this.#chains = /* @__PURE__ */ new Map();
     this.#logger = options.logger;
@@ -57,6 +63,7 @@ class MultichainSDK {
       );
       this.#chains.set(network, sdk);
     }
+    this.liquidations = new import_accounts.MultichainLiquidationsService(this);
   }
   /**
    * Attach all configured chains in parallel.

package/dist/cjs/sdk/OnchainSDK.js

@@ -67,6 +67,8 @@ class OnchainSDK extends import_base.ChainContractsRegister {
   #rwa;
   #marketRegister;
   #priceFeeds;
+  #withdrawalCompressor;
+  #redemptionLogger;
   /**
    * Gas limit applied to read-only `eth_call` requests.
    **/
@@ -83,6 +85,10 @@ class OnchainSDK extends import_base.ChainContractsRegister {
    * Namespace for pool operations.
    */
   pools;
+  /**
+   * Namespace for liquidatable credit accounts discovery.
+   */
+  liquidations;
   /**
    * @param network - Gearbox network type (e.g. `"Mainnet"`, `"Monad"`).
    * @param clientOptions - Connection options (RPC URLs, transport, or client).
@@ -109,6 +115,8 @@ class OnchainSDK extends import_base.ChainContractsRegister {
     }
     this.accounts = new import_accounts.CreditAccountsServiceV310(this);
     this.pools = new import_pools.PoolService(this);
+    this.liquidations = new import_accounts.LiquidationsService(this);
+    this.#withdrawalCompressor = (0, import_accounts.createWithdrawalCompressor)(this);
   }
   /**
    * Initialises the SDK by reading live on-chain state.
@@ -255,6 +263,9 @@ class OnchainSDK extends import_base.ChainContractsRegister {
     this.#marketRegister.hydrate(state);
     this.#rwa = new import_market.RWARegistry(this);
     this.#rwa.setState(state.rwa);
+    if (state.withdrawals) {
+      this.#withdrawalCompressor?.hydrate(state.withdrawals);
+    }
     for (const [name, plugin] of import_utils.TypedObjectUtils.entries(this.plugins)) {
       const pluginState = state.plugins[name];
       if (plugin.hydrate && pluginState) {
@@ -319,6 +330,7 @@ class OnchainSDK extends import_base.ChainContractsRegister {
       addressProvider: this.addressProvider.state,
       ...this.marketRegister.state,
       rwa: this.#rwa.state,
+      withdrawals: this.#withdrawalCompressor?.state,
       plugins: Object.fromEntries(
         import_utils.TypedObjectUtils.entries(this.plugins).map(([name, plugin]) => [
           name,
@@ -535,6 +547,23 @@ class OnchainSDK extends import_base.ChainContractsRegister {
     const [routerAddr, routerV] = routerEntry;
     return (0, import_router.createRouter)(this, routerAddr, routerV);
   }
+  /**
+   * Withdrawal compressor contract for the current chain, or `undefined`
+   * when no withdrawal compressor is supported on it.
+   **/
+  get withdrawalCompressor() {
+    return this.#withdrawalCompressor;
+  }
+  /**
+   * `RedemptionLogger` contract for the current chain, or `undefined` when
+   * it is not deployed on it. Created lazily on first access: the contract
+   * is resolved from the address provider, which is only available after
+   * the SDK is attached or hydrated.
+   **/
+  get redemptionLogger() {
+    this.#redemptionLogger ??= (0, import_accounts.createRedemptionLogger)(this);
+    return this.#redemptionLogger;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {