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

package/dist/cjs/sdk/accounts/withdrawal-compressor/AbstractWithdrawalCompressorContract.js

@@ -107,7 +107,7 @@ class AbstractWithdrawalCompressorContract extends import_base.BaseContract {
       claimable: claimable.map(
         (w) => toClaimableWithdrawal(w, creditManager, this.version >= 313)
       ),
-      pending: pending.map(toPendingWithdrawal).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
+      pending: pending.map((w) => toPendingWithdrawal(w, creditManager, this.version >= 313)).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
     };
   }
   /**
@@ -127,8 +127,8 @@ class AbstractWithdrawalCompressorContract extends import_base.BaseContract {
     return {
       token: resp.token,
       amountIn: resp.amountIn,
-      outputs: resp.outputs.map(toWithdrawalOutput),
-      requestCalls: resp.requestCalls.map(toMultiCall),
+      outputs: [...resp.outputs],
+      requestCalls: [...resp.requestCalls],
       claimableAt: resp.claimableAt
     };
   }
@@ -180,21 +180,8 @@ class AbstractWithdrawalCompressorContract extends import_base.BaseContract {
     ]);
   }
 }
-function toWithdrawalOutput(o) {
-  return { token: o.token, isDelayed: o.isDelayed, amount: o.amount };
-}
-function toMultiCall(c) {
-  return { target: c.target, callData: c.callData };
-}
 function toWithdrawableAsset(a, creditManager) {
-  return {
-    creditManager,
-    token: a.token,
-    withdrawalPhantomToken: a.withdrawalPhantomToken,
-    underlying: a.underlying,
-    withdrawalLength: a.withdrawalLength,
-    maxWithdrawals: a.maxWithdrawals
-  };
+  return { creditManager, ...a };
 }
 function toClaimableWithdrawal(w, creditManager, decodeIntent) {
   let intent;
@@ -205,17 +192,22 @@ function toClaimableWithdrawal(w, creditManager, decodeIntent) {
     token: w.token,
     withdrawalPhantomToken: w.withdrawalPhantomToken,
     withdrawalTokenSpent: w.withdrawalTokenSpent,
-    outputs: w.outputs.map(toWithdrawalOutput),
-    claimCalls: w.claimCalls.map(toMultiCall),
+    outputs: [...w.outputs],
+    claimCalls: [...w.claimCalls],
     intent
   };
 }
-function toPendingWithdrawal(w) {
+function toPendingWithdrawal(w, creditManager, decodeIntent) {
+  let intent;
+  if (decodeIntent && w.extraData && w.extraData !== "0x") {
+    intent = { ...(0, import_intent_codec.decodeDelayedIntent)(w.extraData), creditManager };
+  }
   return {
     token: w.token,
     withdrawalPhantomToken: w.withdrawalPhantomToken,
-    expectedOutputs: w.expectedOutputs.map(toWithdrawalOutput),
-    claimableAt: w.claimableAt
+    expectedOutputs: [...w.expectedOutputs],
+    claimableAt: w.claimableAt,
+    intent
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/sdk/accounts/withdrawal-compressor/addresses.js

@@ -23,28 +23,16 @@ __export(addresses_exports, {
 module.exports = __toCommonJS(addresses_exports);
 const WITHDRAWAL_COMPRESSORS = {
   Mainnet: {
-    310: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
-    313: "0x9605D59E40963ADce8a6895Aa3Fa497320Ef3F3b"
+    address: "0x83e5AaC6590Cf9c6Dd323851a0D66fEc2Bc4F5A3",
+    version: 313
   },
   Monad: {
-    310: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023"
+    address: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
+    version: 310
   }
 };
-function getWithdrawalCompressorAddress(network, version) {
-  const deployments = WITHDRAWAL_COMPRESSORS[network];
-  if (!deployments) {
-    return void 0;
-  }
-  if (version !== void 0) {
-    const address2 = deployments[version];
-    return address2 ? { address: address2, version } : void 0;
-  }
-  const latest = Object.keys(deployments).map(Number).sort((a, b) => b - a)[0];
-  if (latest === void 0) {
-    return void 0;
-  }
-  const address = deployments[latest];
-  return address ? { address, version: latest } : void 0;
+function getWithdrawalCompressorAddress(network) {
+  return WITHDRAWAL_COMPRESSORS[network];
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/accounts/withdrawal-compressor/createWithdrawalCompressor.js

@@ -25,12 +25,10 @@ var import_addresses = require("./addresses.js");
 var import_WithdrawalCompressorV310Contract = require("./WithdrawalCompressorV310Contract.js");
 var import_WithdrawalCompressorV311Contract = require("./WithdrawalCompressorV311Contract.js");
 var import_WithdrawalCompressorV313Contract = require("./WithdrawalCompressorV313Contract.js");
-function createWithdrawalCompressor(sdk, version) {
-  const location = (0, import_addresses.getWithdrawalCompressorAddress)(sdk.networkType, version);
+function createWithdrawalCompressor(sdk) {
+  const location = (0, import_addresses.getWithdrawalCompressorAddress)(sdk.networkType);
   if (!location) {
-    throw new Error(
-      `no withdrawal compressor${version ? ` v${version}` : ""} on ${sdk.networkType}`
-    );
+    throw new Error(`no withdrawal compressor on ${sdk.networkType}`);
   }
   const cached = sdk.getContract(
     location.address

package/dist/esm/abi/IWithdrawalCompressorV313.js

@@ -72,7 +72,8 @@ const iWithdrawalCompressorV313Abi = [
               { name: "amount", type: "uint256", internalType: "uint256" }
             ]
           },
-          { name: "claimableAt", type: "uint256", internalType: "uint256" }
+          { name: "claimableAt", type: "uint256", internalType: "uint256" },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
         ]
       }
     ],

package/dist/esm/abi/compressors/withdrawalCompressor.js

@@ -94,7 +94,8 @@ const withdrawalCompressorAbi = [
               { name: "amount", type: "uint256", internalType: "uint256" }
             ]
           },
-          { name: "claimableAt", type: "uint256", internalType: "uint256" }
+          { name: "claimableAt", type: "uint256", internalType: "uint256" },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
         ]
       }
     ],

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

@@ -1,7 +1,4 @@
-import {
-  AddressMap,
-  BasePlugin
-} from "../../sdk/index.js";
+import { AddressMap, BasePlugin } from "../../sdk/index.js";
 const MAP_LABEL = "delayedWithdrawal";
 class DelayedWithdrawalPlugin extends BasePlugin {
   #withdrawableAssets;
@@ -10,11 +7,7 @@ class DelayedWithdrawalPlugin extends BasePlugin {
       return this.state;
     }
     this.#withdrawableAssets = new 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/esm/preview/preview/applyInnerOperations.js

@@ -4,10 +4,16 @@ import {
 } from "../../plugins/adapters/index.js";
 import {
   AssetsMap,
-  MAX_UINT256,
-  MIN_INT96
+  MAX_UINT256
 } from "../../sdk/index.js";
 import { applyRWAWrapUnwrap } from "./applyRWAWrapUnwrap.js";
+import {
+  ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+  ERROR_MALFORMED_BRACKET,
+  ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+  ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+  ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP
+} from "./types.js";
 function makeInnerOperationsState() {
   return {
     balances: new AssetsMap(),
@@ -21,41 +27,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 === 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: ERROR_MALFORMED_BRACKET,
+            message: "duplicate storeExpectedBalances call"
+          };
         }
         storeSeen = true;
         inBracket = true;
@@ -65,32 +61,83 @@ function applyInnerOperations(sdk, multicall, state) {
         break;
       case "CompareBalances":
         if (!inBracket) {
-          throw new Error(
-            "malformed multicall: compareBalances without a preceding storeExpectedBalances"
-          );
+          opError = {
+            code: 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 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)) {
-          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: 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 === 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: ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+        message: `call to ${op.adapter} outside of a storeExpectedBalances/compareBalances bracket`
+      };
+    }
+    try {
+      applyRWAWrapUnwrap(adapter, op.calldata, balances);
+      return void 0;
+    } catch (e) {
+      return {
+        code: ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+        message: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  if (!(adapter instanceof AbstractAdapterContract)) {
+    return {
+      code: 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: ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+      message: e instanceof Error ? e.message : String(e)
+    };
   }
 }
 function isRWAShare(sdk, adapter) {
@@ -100,23 +147,7 @@ function isRWAShare(sdk, adapter) {
   }
   return false;
 }
-function applyQuotaChanges(initialQuotas, changes) {
-  const final = initialQuotas.clone();
-  for (const { token, balance: change } of changes) {
-    if (change === 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()
-  };
-}
 export {
   applyInnerOperations,
-  applyQuotaChanges,
   makeInnerOperationsState
 };

package/dist/esm/preview/preview/applyQuotaChanges.js

@@ -0,0 +1,19 @@
+import { MIN_INT96 } from "../../sdk/index.js";
+function applyQuotaChanges(initialQuotas, changes) {
+  const final = initialQuotas.clone();
+  for (const { token, balance: change } of changes) {
+    if (change === 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()
+  };
+}
+export {
+  applyQuotaChanges
+};

package/dist/esm/preview/preview/errors.js

@@ -1,17 +1,3 @@
-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;
@@ -22,6 +8,5 @@ class UnsupportedOperationError extends Error {
   }
 }
 export {
-  InvalidTransactionValueError,
   UnsupportedOperationError
 };

package/dist/esm/preview/preview/index.js

@@ -1,4 +1,5 @@
 export * from "./applyInnerOperations.js";
+export * from "./applyQuotaChanges.js";
 export * from "./detectCloseOrRepay.js";
 export * from "./errors.js";
 export * from "./previewAdjustCreditAccount.js";

package/dist/esm/preview/preview/previewAdjustCreditAccount.js

@@ -5,9 +5,12 @@ import {
 } from "../../sdk/index.js";
 import {
   applyInnerOperations,
-  applyQuotaChanges,
   makeInnerOperationsState
 } from "./applyInnerOperations.js";
+import { applyQuotaChanges } from "./applyQuotaChanges.js";
+import {
+  ERROR_UNPRICEABLE_TOKEN
+} from "./types.js";
 import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
 async function previewAdjustCreditAccount(input, operation, options) {
   const { sdk, value = 0n } = input;
@@ -38,22 +41,30 @@ async function previewAdjustCreditAccount(input, operation, options) {
   state.balances = initialBalances.clone();
   state.debt = ca.debt;
   state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
-  applyInnerOperations(sdk, operation.multicall, state);
-  const collateralAdded = unwrapNativeCollateral(
+  let error = applyInnerOperations(sdk, operation.multicall, state);
+  const { assets: collateralAdded, error: unwrapError } = unwrapNativeCollateral(
     state.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
   );
+  error ??= unwrapError;
   const { quotas, quotasChange } = applyQuotaChanges(
     initialQuotas,
     state.quotaChanges
   );
   const assets = state.balances.toAssets(1n);
   const assetsChange = state.balances.difference(initialBalances).toAssets(1n);
-  const totalValue = assets.reduce(
-    (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
-    0n
-  );
+  const totalValue = assets.reduce((acc, { token, balance }) => {
+    try {
+      return acc + market.priceOracle.convert(token, market.underlying, balance);
+    } catch {
+      error ??= {
+        code: ERROR_UNPRICEABLE_TOKEN,
+        message: `cannot price token ${token}`
+      };
+      return acc;
+    }
+  }, 0n);
   return {
     operation: "AdjustCreditAccount",
     creditManager: operation.creditManager,
@@ -66,7 +77,8 @@ async function previewAdjustCreditAccount(input, operation, options) {
     quotas,
     quotasChange,
     assets,
-    assetsChange
+    assetsChange,
+    error
   };
 }
 export {

package/dist/esm/preview/preview/previewCloseOrRepayCreditAccount.js

@@ -21,23 +21,31 @@ async function previewCloseCreditAccount(input, operation, permanent, options) {
   const market = sdk.marketRegister.findByCreditManager(
     operation.creditManager
   );
-  const { state } = await replayMulticall(sdk, operation, options);
+  const { state, error } = await replayMulticall(sdk, operation, options);
   return {
     operation: "CloseCreditAccount",
     permanent,
     creditManager: operation.creditManager,
     creditAccount: operation.creditAccount,
-    receivedAmount: state.collateralWithdrawn.getOrZero(market.underlying)
+    // On a malformed multicall the withdrawn amount depends on best-effort
+    // replayed balances and may be unreliable
+    receivedAmount: state.collateralWithdrawn.getOrZero(market.underlying),
+    error
   };
 }
 async function previewRepayCreditAccount(input, operation, permanent, options) {
   const { sdk, value = 0n } = input;
-  const { ca, state } = await replayMulticall(sdk, operation, options);
-  const collateralAdded = unwrapNativeCollateral(
+  const {
+    ca,
+    state,
+    error: replayError
+  } = await replayMulticall(sdk, operation, options);
+  const { assets: collateralAdded, error: unwrapError } = unwrapNativeCollateral(
     state.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
   );
+  const error = replayError ?? unwrapError;
   const initialTotalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
   return {
     operation: "RepayCreditAccount",
@@ -46,7 +54,10 @@ async function previewRepayCreditAccount(input, operation, permanent, options) {
     creditAccount: operation.creditAccount,
     collateralAdded,
     debtRepaid: initialTotalDebt - state.totalDebt,
-    collateralWithdrawn: state.collateralWithdrawn.toAssets()
+    // On a malformed multicall the MAX_UINT256 withdrawal sentinel resolves
+    // against best-effort replayed balances and may be unreliable
+    collateralWithdrawn: state.collateralWithdrawn.toAssets(),
+    error
   };
 }
 async function replayMulticall(sdk, operation, options) {
@@ -68,8 +79,8 @@ async function replayMulticall(sdk, operation, options) {
   }
   state.debt = ca.debt;
   state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
-  applyInnerOperations(sdk, operation.multicall, state);
-  return { ca, state };
+  const error = applyInnerOperations(sdk, operation.multicall, state);
+  return { ca, state, error };
 }
 export {
   previewCloseOrRepayCreditAccount

package/dist/esm/preview/preview/previewOpenCreditAccount.js

@@ -6,6 +6,9 @@ import {
   applyInnerOperations,
   makeInnerOperationsState
 } from "./applyInnerOperations.js";
+import {
+  ERROR_UNPRICEABLE_TOKEN
+} from "./types.js";
 import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
 function previewOpenCreditAccount(input, operation) {
   const { sdk, value = 0n } = input;
@@ -13,15 +16,25 @@ function previewOpenCreditAccount(input, operation) {
     operation.creditManager
   );
   const state = makeInnerOperationsState();
-  applyInnerOperations(sdk, operation.multicall, state);
-  const collateralValue = state.collateralAdded.sum(
-    (token, balance) => market.priceOracle.convert(token, market.underlying, balance)
-  );
-  const collateral = unwrapNativeCollateral(
+  let error = applyInnerOperations(sdk, operation.multicall, state);
+  let priceError;
+  const collateralValue = state.collateralAdded.sum((token, balance) => {
+    try {
+      return market.priceOracle.convert(token, market.underlying, balance);
+    } catch {
+      priceError ??= {
+        code: ERROR_UNPRICEABLE_TOKEN,
+        message: `cannot price token ${token}`
+      };
+      return 0n;
+    }
+  });
+  const { assets: collateral, error: unwrapError } = unwrapNativeCollateral(
     state.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
   );
+  error ??= unwrapError ?? priceError;
   const assets = state.balances.toAssets(1n);
   return {
     operation: operation.operation,
@@ -32,7 +45,8 @@ function previewOpenCreditAccount(input, operation) {
     debt: state.debt,
     // On opening, initial quotas are zero, so the raw changes are the quotas.
     quotas: state.quotaChanges,
-    assets
+    assets,
+    error
   };
 }
 function inferTargetAsset(multicall, balances) {

package/dist/esm/preview/preview/types.js

@@ -0,0 +1,16 @@
+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;
+export {
+  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
+};

package/dist/esm/preview/preview/unwrapNativeCollateral.js

@@ -1,20 +1,28 @@
 import { AssetsMap, NATIVE_ADDRESS } from "../../sdk/index.js";
-import { InvalidTransactionValueError } from "./errors.js";
+import {
+  ERROR_INVALID_TRANSACTION_VALUE
+} from "./types.js";
 function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
   if (nativeAmount === 0n) {
-    return collateral;
+    return { assets: collateral };
   }
   const balances = new AssetsMap(collateral);
   const wethBalance = balances.get(wethToken) ?? 0n;
   if (wethBalance < nativeAmount) {
-    throw new InvalidTransactionValueError(nativeAmount, wethBalance);
+    return {
+      assets: collateral,
+      error: {
+        code: ERROR_INVALID_TRANSACTION_VALUE,
+        message: `transaction value ${nativeAmount} exceeds WETH collateral ${wethBalance}`
+      }
+    };
   }
   balances.upsert(
     wethToken,
     wethBalance === nativeAmount ? void 0 : wethBalance - nativeAmount
   );
   balances.inc(NATIVE_ADDRESS, nativeAmount);
-  return balances.toAssets();
+  return { assets: balances.toAssets() };
 }
 export {
   unwrapNativeCollateral

package/dist/esm/sdk/OnchainSDK.js

@@ -538,13 +538,10 @@ class OnchainSDK extends ChainContractsRegister {
   /**
    * Lazily returns a withdrawal compressor contract for the current chain.
    *
-   * @param version - Desired compressor version; when omitted, the latest
-   *   version supported on the current chain is used.
-   * @throws If no withdrawal compressor of the given version is supported
-   *   on the current chain.
+   * @throws If no withdrawal compressor is supported on the current chain.
    **/
-  withdrawalCompressor(version) {
-    return createWithdrawalCompressor(this, version);
+  get withdrawalCompressor() {
+    return createWithdrawalCompressor(this);
   }
 }
 export {