@gearbox-protocol/sdk 14.12.0-next.22 → 14.12.0-next.24

package/dist/cjs/plugins/adapters/contracts/MidasRedemptionVaultAdapterContract.js

@@ -77,16 +77,17 @@ class MidasRedemptionVaultAdapterContract extends import_AbstractAdapter.Abstrac
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // redemption spends the mToken down to the leftover, tokenOut arg is
       // the received token
       case "redeemInstantDiff": {
         const [, leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.mToken, leftoverAmount }];
+        this.setLeftover(balances, this.mToken, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/adapters/contracts/PendleRouterAdapterContract.js

@@ -117,27 +117,29 @@ class PendleRouterAdapterContract extends import_AbstractAdapter.AbstractAdapter
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapDiffTokenForPt":
       case "addLiquiditySingleTokenDiff": {
         const [, , , diffInput] = decoded.args;
-        return [
-          {
-            tokenIn: diffInput.tokenIn,
-            leftoverAmount: diffInput.leftoverTokenIn
-          }
-        ];
+        this.setLeftover(
+          balances,
+          diffInput.tokenIn,
+          diffInput.leftoverTokenIn
+        );
+        break;
       }
       case "swapDiffPtForToken": {
         const [market, leftoverPt] = decoded.args;
         const pt = this.#mustFindPendleToken(market, 0 /* PT */);
-        return [{ tokenIn: pt, leftoverAmount: leftoverPt }];
+        this.setLeftover(balances, pt, leftoverPt);
+        break;
       }
       case "removeLiquiditySingleTokenDiff": {
         const [market, leftoverLp] = decoded.args;
         const lp = this.#mustFindPendleToken(market, 1 /* LP */);
-        return [{ tokenIn: lp, leftoverAmount: leftoverLp }];
+        this.setLeftover(balances, lp, leftoverLp);
+        break;
       }
       case "redeemDiffPyToToken": {
         const candidates = this.allowedPairs.filter(
@@ -152,15 +154,11 @@ class PendleRouterAdapterContract extends import_AbstractAdapter.AbstractAdapter
           );
         }
         const [, leftoverPt] = decoded.args;
-        return [
-          {
-            tokenIn: candidates[0].pendleToken,
-            leftoverAmount: leftoverPt
-          }
-        ];
+        this.setLeftover(balances, candidates[0].pendleToken, leftoverPt);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
   #mustFindPendleToken(market, type) {

package/dist/cjs/plugins/adapters/contracts/SecuritizeOnRampAdapterContract.js

@@ -64,15 +64,16 @@ class SecuritizeOnRampAdapterContract extends import_AbstractAdapter.AbstractAda
       liquidityToken: this.#liquidityToken ? this.labelAddress(this.#liquidityToken) : void 0
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // swaps the liquidity token into dsToken
       case "swapDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.liquidityToken, leftoverAmount }];
+        this.setLeftover(balances, this.liquidityToken, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/adapters/contracts/SecuritizeRedemptionGatewayAdapterContract.js

@@ -72,28 +72,29 @@ class SecuritizeRedemptionGatewayAdapterContract extends import_AbstractAdapter.
       redemptionPhantomToken: this.#redemptionPhantomToken ? this.labelAddress(this.#redemptionPhantomToken) : void 0
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
-      // exact-input redemption: burns dsTokenAmount of the DS token in
-      // exchange for the redemption phantom token (which is credited by the
-      // storeExpectedBalances bracket delta, not here)
       case "redeem": {
         const [dsTokenAmount] = decoded.args;
-        const balance = balances.get(this.dsToken) ?? 0n;
-        return [
-          {
-            tokenIn: this.dsToken,
-            leftoverAmount: balance > dsTokenAmount ? balance - dsTokenAmount : 0n
-          }
-        ];
+        this.spendExact(balances, this.dsToken, dsTokenAmount);
+        break;
       }
       // diff-style redemption: spends the DS token down to the leftover
       case "redeemDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.dsToken, leftoverAmount }];
+        this.setLeftover(balances, this.dsToken, leftoverAmount);
+        break;
       }
+      // TODO:
+      // `claim(address[] redeemers)` (the claim call emitted by the
+      // withdrawal compressor) cannot be previewed offline: the redemption
+      // phantom token burn (the compressor's `withdrawalTokenSpent`, i.e.
+      // each redeemer's `getRedemptionAmount()`) lives in per-redeemer clone
+      // contracts and is not recoverable from calldata. For claimable
+      // redeemers it equals the stablecoin credit, but that value is not in
+      // calldata either.
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/adapters/contracts/StakingRewardsAdapterContract.js

@@ -100,21 +100,23 @@ class StakingRewardsAdapterContract extends import_AbstractAdapter.AbstractAdapt
       referral: this.#referral
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "stakeDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.stakingToken, leftoverAmount }];
+        this.setLeftover(balances, this.stakingToken, leftoverAmount);
+        break;
       }
       case "withdrawDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.stakedPhantomToken, leftoverAmount }];
+        this.setLeftover(balances, this.stakedPhantomToken, leftoverAmount);
+        break;
       }
       // no accrued rewards on a freshly opened account
       case "getReward":
-        return [];
+        break;
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/adapters/contracts/TraderJoeRouterAdapterContract.js

@@ -82,14 +82,15 @@ class TraderJoeRouterAdapterContract extends import_AbstractAdapter.AbstractAdap
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapDiffTokensForTokens": {
         const [leftoverAmount, , path] = decoded.args;
-        return [{ tokenIn: path.tokenPath[0], leftoverAmount }];
+        this.setLeftover(balances, path.tokenPath[0], leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/adapters/contracts/UniswapV2AdapterContract.js

@@ -93,14 +93,15 @@ class UniswapV2AdapterContract extends import_AbstractAdapter.AbstractAdapterCon
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "UniswapSwap", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapDiffTokensForTokens": {
         const [leftoverAmount, , path] = decoded.args;
-        return [{ tokenIn: path[0], leftoverAmount }];
+        this.setLeftover(balances, path[0], leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/adapters/contracts/UniswapV3AdapterContract.js

@@ -71,24 +71,21 @@ class UniswapV3AdapterContract extends import_AbstractAdapter.AbstractAdapterCon
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "exactDiffInputSingle": {
         const [params] = decoded.args;
-        return [
-          {
-            tokenIn: params.tokenIn,
-            leftoverAmount: params.leftoverAmount
-          }
-        ];
+        this.setLeftover(balances, params.tokenIn, params.leftoverAmount);
+        break;
       }
       case "exactDiffInput": {
         const [params] = decoded.args;
         const tokenIn = `0x${params.path.replace("0x", "").slice(0, 40)}`;
-        return [{ tokenIn, leftoverAmount: params.leftoverAmount }];
+        this.setLeftover(balances, tokenIn, params.leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
   stringifyFunctionParams(params) {

package/dist/cjs/plugins/adapters/contracts/UniswapV4AdapterContract.js

@@ -81,19 +81,19 @@ class UniswapV4AdapterContract extends import_AbstractAdapter.AbstractAdapterCon
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "UniswapSwap", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapExactInputSingleDiff": {
         const [poolKey, zeroForOne, leftoverAmount] = decoded.args;
-        return [
-          {
-            tokenIn: zeroForOne ? poolKey.token0 : poolKey.token1,
-            leftoverAmount
-          }
-        ];
+        this.setLeftover(
+          balances,
+          zeroForOne ? poolKey.token0 : poolKey.token1,
+          leftoverAmount
+        );
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/adapters/contracts/UpshiftVaultAdapterContract.js

@@ -70,18 +70,20 @@ class UpshiftVaultAdapterContract extends import_AbstractAdapter.AbstractAdapter
       stakedPhantomToken: this.#stakedPhantomToken ? this.labelAddress(this.#stakedPhantomToken) : void 0
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.asset, leftoverAmount }];
+        this.setLeftover(balances, this.asset, leftoverAmount);
+        break;
       }
       case "redeemDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.vault, leftoverAmount }];
+        this.setLeftover(balances, this.vault, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/adapters/contracts/VelodromeV2AdapterContract.js

@@ -74,14 +74,15 @@ class VelodromeV2RouterAdapterContract extends import_AbstractAdapter.AbstractAd
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapDiffTokensForTokens": {
         const [leftoverAmount, , routes] = decoded.args;
-        return [{ tokenIn: routes[0].from, leftoverAmount }];
+        this.setLeftover(balances, routes[0].from, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/adapters/contracts/WstETHV1AdapterContract.js

@@ -65,19 +65,21 @@ class WstETHV1AdapterContract extends import_AbstractAdapter.AbstractAdapterCont
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "wrapDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.stETH, leftoverAmount }];
+        this.setLeftover(balances, this.stETH, leftoverAmount);
+        break;
       }
       // wstETH is the adapter's target contract
       case "unwrapDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.targetContract, leftoverAmount }];
+        this.setLeftover(balances, this.targetContract, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/cjs/plugins/delayed-withdrawal/DelayedWithdrawalPlugin.js

@@ -30,11 +30,7 @@ class DelayedWithdrawalPlugin extends import_sdk.BasePlugin {
       return this.state;
     }
     this.#withdrawableAssets = new import_sdk.AddressMap(void 0, MAP_LABEL);
-    const compressor = this.sdk.withdrawalCompressor();
-    this.sdk.logger?.debug(
-      `loading delayed withdrawal plugin with compressor ${compressor.address}`
-    );
-    const resp = await compressor.getWithdrawableAssetsBatch();
+    const resp = await this.sdk.withdrawalCompressor.getWithdrawableAssetsBatch();
     const byCreditManager = /* @__PURE__ */ new Map();
     for (const cfg of resp) {
       const assets = byCreditManager.get(cfg.creditManager) ?? [];

package/dist/cjs/preview/preview/applyInnerOperations.js

@@ -19,13 +19,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var applyInnerOperations_exports = {};
 __export(applyInnerOperations_exports, {
   applyInnerOperations: () => applyInnerOperations,
-  applyQuotaChanges: () => applyQuotaChanges,
   makeInnerOperationsState: () => makeInnerOperationsState
 });
 module.exports = __toCommonJS(applyInnerOperations_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 makeInnerOperationsState() {
   return {
     balances: new import_sdk.AssetsMap(),
@@ -39,41 +39,31 @@ function makeInnerOperationsState() {
 function applyInnerOperations(sdk, multicall, state) {
   let inBracket = false;
   let storeSeen = false;
+  let error;
   for (const op of multicall) {
+    let opError;
     switch (op.operation) {
       case "AddCollateral":
-        state.collateralAdded.inc(op.token, op.amount);
-        state.balances.inc(op.token, op.amount);
+        applyAddCollateral(state, op);
         break;
-      case "WithdrawCollateral": {
-        const running = state.balances.getOrZero(op.token);
-        const amount = op.amount === import_sdk.MAX_UINT256 ? running > 0n ? running : 0n : op.amount;
-        state.balances.dec(op.token, amount);
-        state.collateralWithdrawn.inc(op.token, amount);
+      case "WithdrawCollateral":
+        applyWithdrawCollateral(state, op);
         break;
-      }
       case "IncreaseBorrowedAmount":
-        state.debt += op.amount;
-        state.totalDebt += op.amount;
-        state.balances.inc(op.token, op.amount);
+        applyIncreaseDebt(state, op);
         break;
-      case "DecreaseBorrowedAmount": {
-        const repaid = op.amount > state.totalDebt ? state.totalDebt : op.amount;
-        state.balances.dec(op.token, repaid);
-        state.totalDebt -= repaid;
-        if (state.debt > state.totalDebt) {
-          state.debt = state.totalDebt;
-        }
+      case "DecreaseBorrowedAmount":
+        applyDecreaseDebt(state, op);
         break;
-      }
       case "UpdateQuota":
         state.quotaChanges.push({ token: op.token, balance: op.change });
         break;
       case "StoreExpectedBalances":
         if (storeSeen) {
-          throw new Error(
-            "malformed multicall: duplicate storeExpectedBalances call"
-          );
+          opError = {
+            code: import_types.ERROR_MALFORMED_BRACKET,
+            message: "duplicate storeExpectedBalances call"
+          };
         }
         storeSeen = true;
         inBracket = true;
@@ -83,32 +73,83 @@ function applyInnerOperations(sdk, multicall, state) {
         break;
       case "CompareBalances":
         if (!inBracket) {
-          throw new Error(
-            "malformed multicall: compareBalances without a preceding storeExpectedBalances"
-          );
+          opError = {
+            code: import_types.ERROR_MALFORMED_BRACKET,
+            message: "compareBalances without a preceding storeExpectedBalances"
+          };
         }
         inBracket = false;
         break;
-      case "Execute": {
-        const adapter = sdk.getContract(op.adapter);
-        if (inBracket) {
-          if (!(adapter instanceof import_adapters.AbstractAdapterContract)) {
-            throw new Error(
-              `call to ${op.adapter} between storeExpectedBalances and compareBalances is not an adapter call`
-            );
-          }
-          adapter.previewBalanceChanges(state.balances, op.calldata);
-        } else if (isRWAShare(sdk, adapter)) {
-          (0, import_applyRWAWrapUnwrap.applyRWAWrapUnwrap)(adapter, op.calldata, state.balances);
-        }
+      case "Execute":
+        opError = applyExecute(sdk, op, inBracket, state.balances);
         break;
-      }
     }
+    error ??= opError;
   }
   if (inBracket) {
-    throw new Error(
-      "malformed multicall: storeExpectedBalances without a matching compareBalances"
-    );
+    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.balances.inc(op.token, op.amount);
+}
+function applyWithdrawCollateral(state, op) {
+  const running = state.balances.getOrZero(op.token);
+  const amount = op.amount === import_sdk.MAX_UINT256 ? running > 0n ? running : 0n : op.amount;
+  state.balances.dec(op.token, amount);
+  state.collateralWithdrawn.inc(op.token, amount);
+}
+function applyIncreaseDebt(state, op) {
+  state.debt += op.amount;
+  state.totalDebt += op.amount;
+  state.balances.inc(op.token, op.amount);
+}
+function applyDecreaseDebt(state, op) {
+  const repaid = op.amount > state.totalDebt ? state.totalDebt : op.amount;
+  state.balances.dec(op.token, repaid);
+  state.totalDebt -= repaid;
+  if (state.debt > state.totalDebt) {
+    state.debt = state.totalDebt;
+  }
+}
+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 {
+    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) {
@@ -118,24 +159,8 @@ function isRWAShare(sdk, adapter) {
   }
   return false;
 }
-function applyQuotaChanges(initialQuotas, changes) {
-  const final = initialQuotas.clone();
-  for (const { token, balance: change } of changes) {
-    if (change === import_sdk.MIN_INT96) {
-      final.upsert(token, 0n);
-    } else {
-      const next = final.getOrZero(token) + change;
-      final.upsert(token, next > 0n ? next : 0n);
-    }
-  }
-  return {
-    quotas: final.toAssets(0n),
-    quotasChange: final.difference(initialQuotas).toAssets()
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   applyInnerOperations,
-  applyQuotaChanges,
   makeInnerOperationsState
 });

package/dist/cjs/preview/preview/applyQuotaChanges.js

@@ -0,0 +1,43 @@
+"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 applyQuotaChanges_exports = {};
+__export(applyQuotaChanges_exports, {
+  applyQuotaChanges: () => applyQuotaChanges
+});
+module.exports = __toCommonJS(applyQuotaChanges_exports);
+var import_sdk = require("../../sdk/index.js");
+function applyQuotaChanges(initialQuotas, changes) {
+  const final = initialQuotas.clone();
+  for (const { token, balance: change } of changes) {
+    if (change === import_sdk.MIN_INT96) {
+      final.upsert(token, 0n);
+    } else {
+      const next = final.getOrZero(token) + change;
+      final.upsert(token, next > 0n ? next : 0n);
+    }
+  }
+  return {
+    quotas: final.toAssets(0n),
+    quotasChange: final.difference(initialQuotas).toAssets()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyQuotaChanges
+});

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

@@ -18,24 +18,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var errors_exports = {};
 __export(errors_exports, {
-  InvalidTransactionValueError: () => InvalidTransactionValueError,
   UnsupportedOperationError: () => UnsupportedOperationError
 });
 module.exports = __toCommonJS(errors_exports);
-class InvalidTransactionValueError extends Error {
-  /** Transaction `msg.value`. */
-  value;
-  /** Amount of wrapped native token added as collateral. */
-  wethCollateral;
-  constructor(value, wethCollateral) {
-    super(
-      `transaction value ${value} exceeds WETH collateral ${wethCollateral}`
-    );
-    this.name = "InvalidTransactionValueError";
-    this.value = value;
-    this.wethCollateral = wethCollateral;
-  }
-}
 class UnsupportedOperationError extends Error {
   /** The parsed operation kind (the `operation` discriminant). */
   operation;
@@ -47,6 +32,5 @@ class UnsupportedOperationError extends Error {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  InvalidTransactionValueError,
   UnsupportedOperationError
 });

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

@@ -16,6 +16,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var preview_exports = {};
 module.exports = __toCommonJS(preview_exports);
 __reExport(preview_exports, require("./applyInnerOperations.js"), module.exports);
+__reExport(preview_exports, require("./applyQuotaChanges.js"), module.exports);
 __reExport(preview_exports, require("./detectCloseOrRepay.js"), module.exports);
 __reExport(preview_exports, require("./errors.js"), module.exports);
 __reExport(preview_exports, require("./previewAdjustCreditAccount.js"), module.exports);
@@ -25,6 +26,7 @@ __reExport(preview_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./applyInnerOperations.js"),
+  ...require("./applyQuotaChanges.js"),
   ...require("./detectCloseOrRepay.js"),
   ...require("./errors.js"),
   ...require("./previewAdjustCreditAccount.js"),