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

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 {

package/dist/esm/sdk/accounts/CreditAccountsServiceV310.js

@@ -782,8 +782,7 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     token,
     intent
   }) {
-    const compressor = this.sdk.withdrawalCompressor();
-    return compressor.getWithdrawalRequestResult(
+    return this.sdk.withdrawalCompressor.getWithdrawalRequestResult(
       creditAccount,
       token,
       amount,
@@ -796,8 +795,7 @@ class CreditAccountsServiceV310 extends SDKConstruct {
   async getPendingWithdrawals({
     creditAccount
   }) {
-    const compressor = this.sdk.withdrawalCompressor();
-    const { claimable, pending } = await compressor.getCurrentWithdrawals(creditAccount);
+    const { claimable, pending } = await this.sdk.withdrawalCompressor.getCurrentWithdrawals(creditAccount);
     return {
       claimableNow: claimable,
       pending
@@ -839,6 +837,45 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     };
     return [storeExpectedBalances, ...preview.requestCalls, compareBalances];
   }
+  /**
+   * {@inheritDoc ICreditAccountsService.assembleClaimDelayedCalls}
+   **/
+  assembleClaimDelayedCalls({
+    creditFacade,
+    claimableNow
+  }) {
+    const record = claimableNow.outputs.reduce(
+      (acc, o) => {
+        const token = o.token.toLowerCase();
+        acc[token] = (acc[token] || 0n) + o.amount;
+        return acc;
+      },
+      {}
+    );
+    const balances = Object.entries(record).filter(([, a]) => a > 10n);
+    const storeExpectedBalances = {
+      target: creditFacade,
+      callData: encodeFunctionData({
+        abi: iCreditFacadeMulticallV310Abi,
+        functionName: "storeExpectedBalances",
+        args: [
+          balances.map(([token, amount]) => ({
+            token,
+            amount: amount > 10n ? amount - 10n : 0n
+          }))
+        ]
+      })
+    };
+    const compareBalances = {
+      target: creditFacade,
+      callData: encodeFunctionData({
+        abi: iCreditFacadeMulticallV310Abi,
+        functionName: "compareBalances",
+        args: []
+      })
+    };
+    return [storeExpectedBalances, ...claimableNow.claimCalls, compareBalances];
+  }
   /**
    * {@inheritDoc ICreditAccountsService.startDelayedWithdrawal}
    **/
@@ -882,44 +919,15 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     const cm = this.sdk.marketRegister.findCreditManager(
       creditAccount.creditManager
     );
-    const record = claimableNow.outputs.reduce(
-      (acc, o) => {
-        const token = o.token.toLowerCase();
-        acc[token] = (acc[token] || 0n) + o.amount;
-        return acc;
-      },
-      {}
-    );
-    const balances = Object.entries(record).filter(([, a]) => a > 10n);
-    const storeExpectedBalances = {
-      target: cm.creditFacade.address,
-      callData: encodeFunctionData({
-        abi: iCreditFacadeMulticallV310Abi,
-        functionName: "storeExpectedBalances",
-        args: [
-          balances.map(([token, amount]) => ({
-            token,
-            amount: amount > 10n ? amount - 10n : 0n
-          }))
-        ]
-      })
-    };
-    const compareBalances = {
-      target: cm.creditFacade.address,
-      callData: encodeFunctionData({
-        abi: iCreditFacadeMulticallV310Abi,
-        functionName: "compareBalances",
-        args: []
-      })
-    };
     const quotaCalls = zeroDebt ? [] : this.#prepareUpdateQuotas(cm.creditFacade.address, {
       minQuota,
       averageQuota
     });
     const operationCalls = [
-      storeExpectedBalances,
-      ...claimableNow.claimCalls,
-      compareBalances,
+      ...this.assembleClaimDelayedCalls({
+        creditFacade: cm.creditFacade.address,
+        claimableNow
+      }),
       ...quotaCalls
     ];
     const calls = zeroDebt ? operationCalls : await this.#prependPriceUpdates(

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

@@ -84,7 +84,7 @@ class AbstractWithdrawalCompressorContract extends 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)
     };
   }
   /**
@@ -104,8 +104,8 @@ class AbstractWithdrawalCompressorContract extends 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
     };
   }
@@ -157,21 +157,8 @@ class AbstractWithdrawalCompressorContract extends 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;
@@ -182,17 +169,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 = { ...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
   };
 }
 export {

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

@@ -1,27 +1,15 @@
 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];
 }
 export {
   getWithdrawalCompressorAddress

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

@@ -2,12 +2,10 @@ import { getWithdrawalCompressorAddress } from "./addresses.js";
 import { WithdrawalCompressorV310Contract } from "./WithdrawalCompressorV310Contract.js";
 import { WithdrawalCompressorV311Contract } from "./WithdrawalCompressorV311Contract.js";
 import { WithdrawalCompressorV313Contract } from "./WithdrawalCompressorV313Contract.js";
-function createWithdrawalCompressor(sdk, version) {
-  const location = getWithdrawalCompressorAddress(sdk.networkType, version);
+function createWithdrawalCompressor(sdk) {
+  const location = 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/types/abi/IWithdrawalCompressorV313.d.ts

@@ -100,6 +100,10 @@ export declare const iWithdrawalCompressorV313Abi: readonly [{
             readonly name: "claimableAt";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "extraData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/abi/compressors/withdrawalCompressor.d.ts

@@ -136,6 +136,10 @@ export declare const withdrawalCompressorAbi: readonly [{
             readonly name: "claimableAt";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "extraData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/permissionless/bindings/compressors/withdrawal-compressor.d.ts

@@ -138,6 +138,10 @@ declare const abi: readonly [{
             readonly name: "claimableAt";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "extraData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/preview/preview/applyInnerOperations.d.ts

@@ -1,6 +1,7 @@
 import { type SdkWithAdapters } from "../../plugins/adapters/index.js";
 import { type Asset, AssetsMap, type PluginsMap } from "../../sdk/index.js";
 import type { InnerOperation } from "../parse/index.js";
+import { type OperationPreviewError } from "./types.js";
 /**
  * Running state threaded through a credit-facade multicall by
  * {@link applyInnerOperations}. Seeded by the caller:
@@ -37,8 +38,7 @@ export interface InnerOperationsState {
     /**
      * Raw `updateQuota` changes, one entry per op. Entries are relative signed
      * changes (with the `MIN_INT96` "disable" sentinel kept as-is), not final
-     * quotas: folding them requires pre-state quotas, see
-     * {@link applyQuotaChanges}.
+     * quotas: folding them requires pre-state quotas, see `applyQuotaChanges`.
      */
     quotaChanges: Asset[];
 }
@@ -48,37 +48,12 @@ export interface InnerOperationsState {
 export declare function makeInnerOperationsState(): InnerOperationsState;
 /**
  * Replays a credit-facade multicall over `state`, mutating it in place in
- * facade execution order. The result is the *minimal guaranteed* post-state:
- * exact deltas for explicit facade calls, exact leftovers for diff-style
- * adapter calls inside `storeExpectedBalances`/`compareBalances` brackets and
- * enforced minimums for bracket targets. Adapter calls outside a bracket are
- * ignored: nothing enforces their outcome on-chain (e.g. reward claims), so
- * their guaranteed balance change is zero.
+ * facade execution order. The result is the *minimal guaranteed* post-state.
  *
- * The exception is RWA wrap/unwrap calls emitted by
- * `CreditAccountsServiceV310`: out-of-bracket ERC4626 adapter calls whose
- * share token is an RWA underlying. Their outcome is essential to the preview
- * (the conversion between the market underlying and its asset); RWA
- * underlyings always convert 1-to-1 with their vault asset, so the conversion
- * is applied directly, see {@link applyRWAWrapUnwrap}.
+ * The function assumes that the call was generated by our frontend using
+ * router/withdrawal compressor, otherwise it returns an error, but still
+ * proceeds best-effort.
  *
- * @throws On malformed `storeExpectedBalances`/`compareBalances` brackets and
- * on bracketed calls to non-adapter targets.
+ * @returns `undefined` on success, the error on a malformed multicall.
  */
-export declare function applyInnerOperations<P extends PluginsMap>(sdk: SdkWithAdapters<P>, multicall: InnerOperation[], state: InnerOperationsState): void;
-/**
- * Applies raw `updateQuota` changes to the account's initial quotas.
- *
- * Each change is applied sequentially: `MIN_INT96` disables the quota, other
- * changes are added to the running quota with the result clamped at zero
- * (quotas cannot go negative on-chain).
- *
- * @param initialQuotas - Per-token quotas before the operation.
- * @param changes - Raw changes recorded by {@link applyInnerOperations}.
- * @returns `quotas` - final non-zero per-token quotas; `quotasChange` -
- * applied (post-clamp) per-token deltas, non-zero entries only.
- */
-export declare function applyQuotaChanges(initialQuotas: AssetsMap, changes: Asset[]): {
-    quotas: Asset[];
-    quotasChange: Asset[];
-};
+export declare function applyInnerOperations<P extends PluginsMap>(sdk: SdkWithAdapters<P>, multicall: InnerOperation[], state: InnerOperationsState): OperationPreviewError | undefined;

package/dist/types/preview/preview/applyQuotaChanges.d.ts

@@ -0,0 +1,24 @@
+import { type Asset, type AssetsMap } from "../../sdk/index.js";
+export interface ApplyQuotaChangesResult {
+    /**
+     * Final non-zero per-token quotas.
+     */
+    quotas: Asset[];
+    /**
+     * Applied (post-clamp) per-token deltas, non-zero entries only.
+     */
+    quotasChange: Asset[];
+}
+/**
+ * Applies raw `updateQuota` changes to the account's initial quotas.
+ *
+ * Each change is applied sequentially: `MIN_INT96` disables the quota, other
+ * changes are added to the running quota with the result clamped at zero
+ * (quotas cannot go negative on-chain).
+ *
+ * @param initialQuotas - Per-token quotas before the operation.
+ * @param changes - Raw changes recorded by `applyInnerOperations`.
+ * @returns `quotas` - final non-zero per-token quotas; `quotasChange` -
+ * applied (post-clamp) per-token deltas, non-zero entries only.
+ */
+export declare function applyQuotaChanges(initialQuotas: AssetsMap, changes: Asset[]): ApplyQuotaChangesResult;

package/dist/types/preview/preview/errors.d.ts

@@ -1,15 +1,3 @@
-/**
- * Thrown when a transaction's attached native value (`msg.value`) does not fit
- * into the WETH collateral declared by the multicall: such a transaction is
- * malformed and would not execute successfully.
- */
-export declare class InvalidTransactionValueError extends Error {
-    /** Transaction `msg.value`. */
-    readonly value: bigint;
-    /** Amount of wrapped native token added as collateral. */
-    readonly wethCollateral: bigint;
-    constructor(value: bigint, wethCollateral: bigint);
-}
 /**
  * Thrown by `previewOperation` for parsed operations it cannot preview yet.
  * Currently only pool operations and credit account opening are supported.

package/dist/types/preview/preview/index.d.ts

@@ -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/types/preview/preview/previewAdjustCreditAccount.d.ts

@@ -1,7 +1,7 @@
 import { type PluginsMap } from "../../sdk/index.js";
 import type { MulticallOperation, RWAMulticallOperation } from "../parse/index.js";
 import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
-import type { AdjustCreditAccountPreview } from "./types.js";
+import { type AdjustCreditAccountPreview } from "./types.js";
 /**
  * Previews a `multicall`/`botMulticall` operation on an existing credit
  * account: fetches the account's pre-state (unless provided via options),

package/dist/types/preview/preview/previewOpenCreditAccount.d.ts

@@ -1,5 +1,5 @@
 import { type PluginsMap } from "../../sdk/index.js";
 import type { OpenCreditAccountOperation, RWAOpenCreditAccountOperation } from "../parse/index.js";
 import type { PreviewOperationInput } from "../types.js";
-import type { OpenCreditAccountPreview } from "./types.js";
+import { type OpenCreditAccountPreview } from "./types.js";
 export declare function previewOpenCreditAccount<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: OpenCreditAccountOperation | RWAOpenCreditAccountOperation): OpenCreditAccountPreview;

package/dist/types/preview/preview/types.d.ts

@@ -1,6 +1,58 @@
 import type { Address } from "viem";
 import type { Asset } from "../../sdk/index.js";
 import type { PoolOperationType } from "../parse/index.js";
+/**
+ * Broken `storeExpectedBalances`/`compareBalances` bracket structure:
+ * `storeExpectedBalances` without a matching `compareBalances`, more than one
+ * bracket, or `compareBalances` without a preceding `storeExpectedBalances`.
+ * We expect transactions that were generated by our frontend using router/withdrawal compressor
+ **/
+export declare const ERROR_MALFORMED_BRACKET = 1001;
+/**
+ * Adapter call outside a `storeExpectedBalances`/`compareBalances` bracket
+ * We expect transactions that were generated by our frontend using router/withdrawal compressor,
+ **/
+export declare const ERROR_ADAPTER_CALL_OUTSIDE_BRACKET = 1002;
+/**
+ * Bracketed call whose target is not an adapter (or adapter that is not known to the SDK)
+ **/
+export declare const ERROR_NON_ADAPTER_CALL_IN_BRACKET = 1003;
+/**
+ * Bracketed adapter call cannot be replayed (undecodable/unsupported calldata)
+ **/
+export declare const ERROR_UNPREVIEWABLE_ADAPTER_CALL = 1004;
+/**
+ * Out-of-bracket RWA wrap/unwrap calldata cannot be decoded
+ **/
+export declare const ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP = 1005;
+/**
+ * `msg.value` does not fit into the declared WETH collateral
+ * Transactions can have arbitrary value, but the ones that we create
+ * using our frontend should have a value that fits into the declared WETH collateral.
+ **/
+export declare const ERROR_INVALID_TRANSACTION_VALUE = 1006;
+/** A token in the preview could not be priced by the oracle */
+export declare const ERROR_UNPRICEABLE_TOKEN = 2001;
+/**
+ * Non-throwing preview failure. When set on a preview, all fields are still
+ * computed best-effort, but some of them may be unreliable.
+ */
+export interface OperationPreviewError {
+    /**
+     * Numeric http-style error code, see the `ERROR_*` constants:
+     * - 1xxx: the transaction is malformed (we expect transactions
+     *   that were generated by our fromtend using router/withdrawal compressor)
+     *   and fields derived from replayed balances
+     *   may be unreliable;
+     * - 2xxx: the transaction may be fine, but the SDK could not fully
+     *   evaluate the preview (e.g. a token could not be priced).
+     */
+    code: number;
+    /**
+     * Human-readable details of the specific failure
+     */
+    message: string;
+}
 export interface PoolOperationPreview {
     operation: PoolOperationType;
     /**
@@ -27,6 +79,11 @@ export interface PoolOperationPreview {
      * (previewDeposit/previewRedeem).
      */
     tokenOut: Asset;
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort
+     */
+    error?: OperationPreviewError;
 }
 export interface OpenCreditAccountPreview {
     operation: "OpenCreditAccount" | "RWAOpenCreditAccount";
@@ -64,6 +121,12 @@ export interface OpenCreditAccountPreview {
      * as estimated by router
      */
     assets: Asset[];
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort, but derived fields (`assets`, `target`,
+     * `collateralValue`) may be unreliable in that case.
+     */
+    error?: OperationPreviewError;
 }
 export interface AdjustCreditAccountPreview {
     operation: "AdjustCreditAccount";
@@ -116,6 +179,12 @@ export interface AdjustCreditAccountPreview {
      * Assets after minus assets before
      */
     assetsChange: Asset[];
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort, but derived fields (`assets`, `assetsChange`,
+     * `totalValue`) may be unreliable in that case.
+     */
+    error?: OperationPreviewError;
 }
 export interface CloseCreditAccountPreview {
     operation: "CloseCreditAccount";
@@ -139,6 +208,12 @@ export interface CloseCreditAccountPreview {
      * withdrawal)
      */
     receivedAmount: bigint;
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort, but the
+     * balance-derived `receivedAmount` may be unreliable in that case.
+     */
+    error?: OperationPreviewError;
 }
 export interface RepayCreditAccountPreview {
     operation: "RepayCreditAccount";
@@ -173,6 +248,12 @@ export interface RepayCreditAccountPreview {
      * Total debt repaid: principal + accrued interest + fees, in underlying
      */
     debtRepaid: bigint;
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort, but the
+     * balance-derived `collateralWithdrawn` may be unreliable in that case.
+     */
+    error?: OperationPreviewError;
 }
 /**
  * Result of previewing a raw operation calldata: currently pool operations and