@gearbox-protocol/sdk 15.1.0-next.2 → 15.1.0-next.21

package/dist/types/sdk/accounts/intents/operations.d.ts

@@ -0,0 +1,215 @@
+import { ClaimableWithdrawal, RequestableWithdrawal, WithdrawalOutput } from "../withdrawal-compressor/types.js";
+import { Asset } from "../../base/types.js";
+import { MultiCall } from "../../types/transactions.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { EncodableCreditAccountOperation } from "../types.js";
+import { calcQuotaUpdate } from "../../../common-utils/utils/creditAccount/quota-utils.js";
+import { CreditAccountSlice } from "./types.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/operations.d.ts
+/**
+ * The operation vocabulary: one logical step of an intent, carrying both the
+ * calldata that realises it and the amounts it was computed from.
+ *
+ * A superset of {@link EncodableCreditAccountOperation}: same discriminants,
+ * plus the quoted amounts the preview and the tests read, plus the RWA legs
+ * that come from their own assemblers rather than from `assembleCaOperations`.
+ */
+type AccountCalculatorOperation = AddCollateralOperation | IncreaseDebtOperation | DecreaseDebtOperation | SwapOperation | WithdrawCollateralOperation | QuotaUpdateOperation | WrapRwaCollateralOperation | UnwrapRwaCollateralOperation | StartDelayedWithdrawalOperation | ClaimDelayedWithdrawalOperation;
+/**
+ * Compile-time proof that the engine's operations really are the SDK's own
+ * encodable ones with the quoted amounts attached, so the two cannot drift into
+ * parallel vocabularies for the same facade calls.
+ */
+type Extends<A extends B, B> = A;
+type _EngineOpsAreEncodable = Extends<Extract<AccountCalculatorOperation, {
+  type: EncodableCreditAccountOperation["type"];
+}>, EncodableCreditAccountOperation>;
+interface AddCollateralOperation {
+  type: "addCollateral";
+  token: Address;
+  amount: bigint;
+  value?: bigint;
+  calls: MultiCall[];
+}
+declare function buildAddCollateralOperation(input: {
+  token: Address;
+  amount: bigint;
+  value?: bigint;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): AddCollateralOperation;
+interface IncreaseDebtOperation {
+  type: "increaseDebt";
+  amount: bigint;
+  calls: MultiCall[];
+}
+declare function buildIncreaseDebtOperation(input: {
+  amount: bigint;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): IncreaseDebtOperation;
+interface DecreaseDebtOperation {
+  type: "decreaseDebt";
+  amount: bigint;
+  /**
+   * The repayment settles the loan rather than shrinking it, so the call names
+   * no amount and the facade takes everything outstanding. `amount` is still
+   * the debt as it was read, which is what the projection is built on; the
+   * difference is the interest that accrues before the transaction lands.
+   */
+  full?: boolean;
+  calls: MultiCall[];
+}
+declare function buildDecreaseDebtOperation(input: {
+  amount: bigint;
+  full?: boolean;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): DecreaseDebtOperation;
+interface WithdrawCollateralOperation {
+  type: "withdrawCollateral";
+  token: Address;
+  amount: bigint;
+  /** Wallet recipient for withdrawn tokens — never a token address. */
+  to: Address;
+  /**
+   * The call names no amount and the facade hands over the whole balance, so a
+   * swap that beat its floor does not strand the surplus on the account.
+   * `amount` remains the figure the projection was built on.
+   */
+  all?: boolean;
+  calls: MultiCall[];
+}
+declare function buildWithdrawCollateralOperation(input: {
+  token: Address;
+  amount: bigint;
+  to: Address;
+  all?: boolean;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): WithdrawCollateralOperation;
+/** Routed conversion: one or more tokens in, one token out. */
+interface SwapOperation {
+  type: "swap";
+  from: Asset[];
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}
+/** One routed leg, with the amounts it was quoted at. */
+declare function buildSwapOperation(input: {
+  tokenIn: Address;
+  amountIn: bigint;
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}): SwapOperation;
+/**
+ * The many-to-one leg an exit routes: every balance listed goes in, and the
+ * underlying comes out.
+ */
+declare function buildCloseSwapOperation(input: {
+  from: Asset[];
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}): SwapOperation;
+interface QuotaUpdateOperation {
+  type: "changeQuota";
+  desiredQuota: Record<Address, Asset>;
+  quotaIncrease: Asset[];
+  quotaDecrease: Asset[];
+  calls: MultiCall[];
+}
+type QuotaUpdateState = ReturnType<typeof calcQuotaUpdate>;
+declare function buildQuotaUpdateOperation(input: {
+  update: QuotaUpdateState;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): QuotaUpdateOperation;
+interface WrapRwaCollateralOperation {
+  type: "wrapRwaCollateral";
+  /** Amount of RWA asset wrapped. */
+  amount: bigint;
+  /** RWA asset token (wrap source). */
+  tokenIn: Address;
+  /** Underlying received after wrap. */
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}
+interface UnwrapRwaCollateralOperation {
+  type: "unwrapRwaCollateral";
+  /** Amount of wrapped underlying unwrapped. */
+  amount: bigint;
+  /** Wrapped underlying token (unwrap source). */
+  tokenIn: Address;
+  /** RWA asset received after unwrap. */
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}
+interface RwaLegInput {
+  tokenIn: Address;
+  amountIn: bigint;
+  tokenOut: Address;
+  amountOut: bigint;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}
+/** Wraps an RWA asset into the market underlying. */
+declare function buildWrapRwaCollateralOperation(input: RwaLegInput): Promise<WrapRwaCollateralOperation>;
+/** Unwraps the market underlying back into its RWA asset. */
+declare function buildUnwrapRwaCollateralOperation(input: RwaLegInput): Promise<UnwrapRwaCollateralOperation>;
+/**
+ * The request that starts a redemption: spends the source token and receives
+ * the phantom token standing in for the payout until it matures.
+ */
+interface StartDelayedWithdrawalOperation {
+  type: "startDelayedWithdrawal";
+  /** Source token the redemption is requested from. */
+  token: Address;
+  /** Amount of `token` the issuer burns; capped at the account balance. */
+  amountIn: bigint;
+  /** Request outputs; a delayed one is the phantom token, not the payout. */
+  outputs: WithdrawalOutput[];
+  /** Whether anything at all has to be waited for. */
+  settlement: "instant" | "delayed";
+  calls: MultiCall[];
+}
+declare function buildStartDelayedWithdrawalOperation(input: {
+  preview: RequestableWithdrawal;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): StartDelayedWithdrawalOperation;
+/**
+ * The claim of a matured delayed withdrawal: burns the phantom and credits the
+ * outputs the compressor reports.
+ */
+interface ClaimDelayedWithdrawalOperation {
+  type: "claimDelayedWithdrawal";
+  /** Source token the delayed withdrawal was requested from. */
+  token: Address;
+  withdrawalPhantomToken: Address;
+  withdrawalTokenSpent: bigint;
+  /** Claim outputs as returned by the compressor (incl. `isDelayed`). */
+  outputs: WithdrawalOutput[];
+  calls: MultiCall[];
+}
+declare function buildClaimDelayedWithdrawalOperation(input: {
+  claimable: ClaimableWithdrawal;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): ClaimDelayedWithdrawalOperation;
+/**
+ * What a request or a claim puts on the account right away, as opposed to what
+ * only the phantom token represents.
+ */
+declare function instantOutput(outputs: WithdrawalOutput[], token?: Address): {
+  token: Address;
+  amount: bigint;
+} | undefined;
+//#endregion
+export { AccountCalculatorOperation, AddCollateralOperation, ClaimDelayedWithdrawalOperation, DecreaseDebtOperation, IncreaseDebtOperation, QuotaUpdateOperation, QuotaUpdateState, RwaLegInput, StartDelayedWithdrawalOperation, SwapOperation, UnwrapRwaCollateralOperation, WithdrawCollateralOperation, WrapRwaCollateralOperation, _EngineOpsAreEncodable, buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseSwapOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, instantOutput };

package/dist/types/sdk/accounts/intents/plan.d.ts

@@ -0,0 +1,191 @@
+import { DelayedIntent } from "../../../model/delayed-intents.js";
+import "../../../model/index.js";
+import { ClaimableWithdrawal } from "../withdrawal-compressor/types.js";
+import { AddCollateralIntent, AdjustLeverageIntent, DepositStrategyIntent, RepayStrategyIntent, WithdrawAssetIntent, WithdrawStrategyIntent } from "./types.js";
+import { DebtBand } from "./math.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/plan.d.ts
+/**
+ * Planning: an intent becomes a short list of {@link Step}s.
+ *
+ * Every intent is a walk along the same chain —
+ *
+ * ```
+ * wallet ─add─▶ account ─convert(in→U)─▶ borrow | repay ─convert(U→out)─▶ ─withdraw─▶ wallet
+ * ```
+ *
+ * — so a plan is just which slots are filled and by how much. Planners are
+ * pure: they read an {@link AccountView} and return steps; nothing here touches
+ * the router or the chain. Identity converts (`from === to`) are legitimate
+ * plan entries — the realiser drops them after checking the balance — which is
+ * what lets one planner cover every "S is / is not the underlying" shape.
+ */
+/** Amount of a step: fixed, or whatever the previous step produced. */
+type Amount = bigint | {
+  raised: true;
+  max?: bigint;
+};
+/** Whatever the previous convert produced. */
+declare const RAISED: Amount;
+type Step = {
+  kind: "add";
+  token: Address;
+  amount: bigint;
+  value: bigint | undefined;
+} | {
+  kind: "borrow";
+  amount: bigint;
+} |
+/**
+ * Repays up to `amount`, never more than the underlying on the account minus
+ * `keep` — a routing shortfall shows up as slightly less debt repaid.
+ */
+{
+  kind: "repay";
+  amount: Amount;
+  keep?: bigint;
+} | {
+  kind: "convert";
+  from: Address;
+  to: Address;
+  amount: Amount;
+} | {
+  kind: "withdraw";
+  token: Address;
+  amount: Amount;
+  to: Address;
+} |
+/**
+ * Sells every balance the account holds into the underlying in one
+ * many-to-one route. Only an exit asks for this: the whole position is
+ * leaving, so the router is given all of it at once rather than one leg per
+ * token, and there is nothing left to price a fixed input against.
+ */
+{
+  kind: "closeAll";
+} |
+/**
+ * Redeems `amount` of `token` through its issuer instead of a DEX, keeping
+ * `reserve` of it on the account. `record` is written into the request and
+ * read back at claim time, which is what lets the tail be planned then.
+ */
+{
+  kind: "request";
+  token: Address;
+  amount: bigint;
+  reserve: bigint;
+  record: DelayedIntent;
+} | {
+  kind: "claim";
+  claimable: ClaimableWithdrawal;
+} |
+/**
+ * Hands whatever is left on the account to `to`, each balance in the token it
+ * stands in. Only an exit asks for this: the amounts are whatever the legs
+ * before it happen to leave, which no planner can name in advance.
+ */
+{
+  kind: "sweep";
+  to: Address;
+} |
+/**
+ * Drops every quota the account holds, in the same transaction and before
+ * whatever follows. Only a plan that leaves no debt behind asks for this:
+ * quota fees accrue on the quota, not on the loan, so a quota outliving the
+ * debt it backed would keep charging an account that owes nothing.
+ */
+{
+  kind: "clearQuotas";
+};
+/** What a planner is allowed to know about the account. */
+interface AccountView {
+  underlying: Address;
+  /** Raw asset of an RWA market (e.g. USDC behind dcUSDC); undefined otherwise. */
+  rwaAsset: Address | undefined;
+  debt: bigint;
+  /** TVL − debt, in underlying. */
+  collateral: bigint;
+  band: DebtBand;
+  balanceOf(token: Address): bigint;
+  /** Oracle conversion, RWA-aware. */
+  price(from: Address, to: Address, amount: bigint): bigint;
+  /** Most valuable non-phantom balance, or undefined when there is none. */
+  fattest(exclude?: Address[]): Address | undefined;
+}
+/** Intent 5: the token lands as is; debt is untouched. */
+declare function planAddCollateral(intent: Omit<AddCollateralIntent, "type">): Step[];
+/** Intent 4: one asset out at fixed debt. */
+declare function planWithdrawAsset(intent: Omit<WithdrawAssetIntent, "type">, view: AccountView): Step[];
+/** Intent 6: collateral fixed, debt retargeted to `C0 · (L1 − 1)`. */
+declare function planAdjustLeverage(intent: Omit<AdjustLeverageIntent, "type">, view: AccountView): Step[];
+/** Intents 1.1 / 1.2: collateral grows by `a`, debt grows to match. */
+declare function planDeposit(intent: Omit<DepositStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 3: funding comes in from the wallet and goes straight into the debt.
+ * Collateral never moves, so the whole plan is the funding's way to `U`.
+ *
+ * Funding in `U` needs no way there: it lands and is repaid, which is the whole
+ * plan. An RWA market also takes the raw asset behind its underlying, and that
+ * one is wrapped on the way in.
+ *
+ * `MAX_UINT256` settles the loan: the wallet is asked for the debt as it stands
+ * plus the headroom {@link SETTLE_MARGIN} allows for the interest of the blocks
+ * still to come, since the facade is told to repay everything outstanding
+ * rather than the amount quoted here.
+ */
+declare function planRepay(intent: Omit<RepayStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 2.1: `W` of value leaves, debt shrinks by `D0 · W / C0` so leverage
+ * holds. Both are funded by the source `S`.
+ */
+declare function planWithdraw(intent: Omit<WithdrawStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 2.1 against a source that cannot be sold on a DEX.
+ *
+ * Some collateral only converts through its issuer — a Securitize dsToken, a
+ * Mellow share — which answers a redemption request now and pays out days
+ * later. The trade is unchanged; what changes is that the proceeds do not exist
+ * yet, so this half only requests the redemption:
+ *
+ * ```
+ * request(S, W + dD) → [days] → claim → convert → repay → withdraw
+ * ```
+ *
+ * The tail is planned at claim time by {@link planFinishWithdraw}, from the
+ * intent this request records — only then is the claimed amount, and the token
+ * it arrived in, known.
+ */
+declare function planWithdrawDelayed(intent: Omit<WithdrawStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 6.2 against a position token that only redeems through its issuer.
+ *
+ * Only deleveraging can be delayed: raising leverage borrows and buys, both of
+ * which settle at once. The request covers whatever idle underlying does not
+ * already, and the tail repays from the claim.
+ */
+declare function planAdjustLeverageDelayed(intent: Omit<AdjustLeverageIntent, "type">, view: AccountView): Step[];
+/** Everything claimed goes into the debt. */
+declare function planFinishDecreaseLeverage(claimable: ClaimableWithdrawal, claimed: {
+  token: Address;
+  amount: bigint;
+}, view: AccountView): Step[];
+/**
+ * The claim is split between the promised payout `W` and the debt the leading
+ * half deferred: the payout is served first, the debt gets what is left, so a
+ * routing shortfall shows as leverage a touch above target rather than as a
+ * payout the wallet was promised and did not get.
+ */
+declare function planFinishWithdraw(intent: {
+  withdrawToken: Address;
+  withdrawAmount: bigint;
+  debtRepaid: bigint;
+  sourceToken: Address;
+  to: Address;
+}, claimable: ClaimableWithdrawal, claimed: {
+  token: Address;
+  amount: bigint;
+}, view: AccountView): Step[];
+/** Nothing is owed beyond the claim: the tokens land and quotas catch up. */
+declare function planFinishClaimOnly(claimable: ClaimableWithdrawal): Step[];
+//#endregion
+export { AccountView, Amount, RAISED, Step, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };

package/dist/types/sdk/accounts/intents/realize.d.ts

@@ -0,0 +1,35 @@
+import { MultiCall } from "../../types/transactions.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { CreditAccountSlice, DelayedStart, OperationState } from "./types.js";
+import { AccountCalculatorOperation } from "./operations.js";
+import "../../index.js";
+import { Step } from "./plan.js";
+//#region src/sdk/accounts/intents/realize.d.ts
+interface RealizeProps {
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  /** Router slippage in PERCENTAGE_FORMAT (100% = 10_000). */
+  slippage: number;
+  /** Extra quota headroom in PERCENTAGE_FORMAT. */
+  quotaReserve: number | undefined;
+}
+interface Realized {
+  operations: AccountCalculatorOperation[];
+  state: OperationState;
+  calls: MultiCall[];
+  /** Set when the plan started a redemption, i.e. it needs a tail. */
+  delayed: DelayedStart | undefined;
+}
+/**
+ * Turns a plan into operations: the one place that talks to the router, knows
+ * how an RWA leg differs from a swap, and keeps the running balances.
+ *
+ * Steps are applied to a ledger as they are built, so every leg sees the
+ * balances the previous ones left behind: a swap only spends what the plan
+ * says and keeps the rest of its input token in place, a repayment never
+ * exceeds the underlying actually raised. Once the walk is done the projected
+ * balances yield the quota update and the reported state.
+ */
+declare function realize(steps: Step[], props: RealizeProps): Promise<Realized>;
+//#endregion
+export { RealizeProps, Realized, realize };

package/dist/types/sdk/accounts/intents/testing/delayed.d.ts

@@ -0,0 +1,50 @@
+import { ClaimableWithdrawal } from "../../withdrawal-compressor/types.js";
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice, ResumableIntent } from "../types.js";
+import "../../../index.js";
+import { ExpectedFlowOp } from "./expect.js";
+import { ANY, MarketSdkExtras, RWA_ASSET, UND } from "./market.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/testing/delayed.d.ts
+declare const FIXTURE_PHANTOM: Address;
+interface TailCase {
+  claimedToken: Address;
+  claimedAmount: bigint;
+  postClaimTotalValue: bigint;
+  postClaimDebt: bigint;
+  /** The operations the tail is expected to produce. */
+  tailOps: ExpectedFlowOp[];
+  expectedQuotaBalance?: bigint;
+  /**
+   * Pre-existing balances besides the withdrawal phantom. Defaults to
+   * `postClaimTotalValue − claimed value` in UND. Cases claiming UND override
+   * it with another token so the claimed balance stays distinguishable.
+   */
+  baseAssets?: CreditAccountSlice["tokens"];
+}
+/** Claimed proceeds converted to UND (mirrors the mock price oracle). */
+declare function claimedValueInUnd(amount: bigint, token: Address): bigint;
+/**
+ * Mock sdk for a tail case. The phantom token inherits the claimed token's
+ * decimals, so any 1:1 rescale through it stays the identity.
+ */
+declare function buildTailSdk(c: Pick<TailCase, "claimedToken">, extras?: MarketSdkExtras & {
+  phantom?: Address;
+}): OnchainSDK;
+/** The matured withdrawal a tail case claims. */
+declare function buildClaimable(c: Pick<TailCase, "claimedToken" | "claimedAmount">): ClaimableWithdrawal;
+/** Props for `finishIntent`: the account after the delay, plus the claimable. */
+declare function buildFinishProps<T extends ResumableIntent>(args: {
+  intent: T;
+  case: TailCase;
+  sdk: OnchainSDK;
+}): {
+  intent: T;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  claimable: ClaimableWithdrawal;
+  slippage: undefined;
+};
+//#endregion
+export { ANY, RWA_ASSET, TailCase, UND };

package/dist/types/sdk/accounts/intents/testing/expect.d.ts

@@ -1,30 +1,22 @@
 import { MultiCall } from "../../../types/transactions.js";
-import { AdjustState, IntentPreviewResult } from "../types.js";
-import { ClaimDelayedWithdrawalOperation } from "../operations/claim-delayed/index.js";
-import { CloseCreditAccountOperation } from "../operations/close-credit-account/index.js";
-import { QuotaUpdateOperation } from "../operations/quota-update/index.js";
-import { AccountCalculatorOperation } from "../operations/types.js";
-import "../operations/index.js";
+import { DelayedStartResult, IntentPreviewResult, OperationState } from "../types.js";
+import { AccountCalculatorOperation } from "../operations.js";
 import "../../../index.js";
 import { Address } from "viem";
 //#region src/sdk/accounts/intents/testing/expect.d.ts
 /**
  * Spec expectation: exact op count + type + tokens + amounts + calls.
- * Ported from intent-calculator `expectOpsExact`, reduced to the op types the
- * resume flows produce. Shared offchain fixtures may omit `calls` (treated as
- * `[]`); onchain expectations should set sentinel calls via
- * {@link withOnchainOpCalls}.
+ * Shared offchain fixtures may omit `calls` (treated as `[]`); onchain
+ * expectations should set sentinel calls via {@link withOnchainOpCalls}.
  */
 type CallsOptional<T> = T extends {
   calls: MultiCall[];
 } ? Omit<T, "calls"> & {
   calls?: MultiCall[];
 } : T;
-type ExpectedFlowOp = CallsOptional<ClaimDelayedWithdrawalOperation | QuotaUpdateOperation | CloseCreditAccountOperation | Extract<AccountCalculatorOperation, {
-  type: "swap" | "decreaseDebt" | "withdrawCollateral" | "unwrapRwaCollateral" | "wrapRwaCollateral";
-}>>;
+type ExpectedFlowOp = CallsOptional<AccountCalculatorOperation>;
 /**
- * Fills sentinel `calls` for onchain resume expectations. Shared fixtures keep
+ * Fills sentinel `calls` for onchain expectations. Shared fixtures keep
  * `calls: []` for offchain; onchain tests map through this helper.
  */
 declare function withOnchainOpCalls(ops: ExpectedFlowOp[]): ExpectedFlowOp[];
@@ -33,20 +25,24 @@ declare function expectOpsArrayExact(ops: AccountCalculatorOperation[], expected
 /** Asserts exact calls on a raw MultiCall array (target + callData). */
 declare function expectCallsArrayExact(calls: MultiCall[], expected: MultiCall[], label?: string): void;
 /**
- * Asserts a successful adjust-style resume preview: ok, instant branch present,
- * exact calls (empty unless `expectedCalls` is provided), metrics from the
- * post-claim CA, and exact operations (incl. changeQuota).
- * Returns the adjust preview state for further asset/quota assertions.
+ * Asserts a successful preview: ok, exact calls (empty unless `expectedCalls`
+ * is provided), post-operation metrics, and exact operations (incl. the
+ * trailing changeQuota).
+ * Returns the projected state for further asset/quota assertions.
  */
-declare function expectAdjustResumePreview(result: IntentPreviewResult, args: {
+declare function expectAdjustPreview(result: IntentPreviewResult | DelayedStartResult, args: {
   totalValue: bigint;
   accountDebt: bigint;
   expectedOps: ExpectedFlowOp[];
   expectedCalls?: MultiCall[];
-}): AdjustState;
+}): OperationState;
+/** Asserts the preview failed for a specific reason. */
+declare function expectPreviewError(result: IntentPreviewResult | DelayedStartResult, reason: Extract<IntentPreviewResult, {
+  ok: false;
+}>["reason"]): void;
 declare function assetBalance(assets: Array<{
   token: Address;
   balance: bigint;
 }>, token: Address): bigint;
 //#endregion
-export { ExpectedFlowOp, assetBalance, expectAdjustResumePreview, expectCallsArrayExact, expectOpsArrayExact, withOnchainOpCalls };
+export { ExpectedFlowOp };

package/dist/types/sdk/accounts/intents/testing/market.d.ts

@@ -0,0 +1,91 @@
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice } from "../types.js";
+import "../../../index.js";
+import { MockDelayedVenue, MockQuotaEntry } from "./sdk-mock.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/testing/market.d.ts
+/**
+ * Shared market fixture — token set, prices, decimals, quotas and CM/facade
+ * addresses — used by every intent spec.
+ *
+ * `UND` deliberately has 8 decimals while `ANY`/`ANY2` have 18, so that any
+ * decimals-rescaling bug shows up as a wrong amount rather than passing by
+ * coincidence. `UND` is priced at 2 and the others at 1 for the same reason.
+ */
+declare const UND_DECIMALS = 8;
+declare const TOK_DECIMALS = 18;
+declare const UND: Address;
+declare const ANY: Address;
+declare const ANY2: Address;
+declare const RWA_ASSET: Address;
+/**
+ * Position token that converts 1:1 with `UND` (same decimals, same price).
+ *
+ * The mock router echoes the input amount as the output amount, so a 1:1 pair is
+ * the only way a swap leg's expected amounts stay decimals-correct. Use `POS`
+ * for flows whose amounts cross a swap, and `ANY` where they do not.
+ */
+declare const POS: Address;
+/** Second 1:1 token, for flows routing between two non-underlying tokens. */
+declare const POS2: Address;
+declare const CREDIT_MANAGER: Address;
+declare const CREDIT_FACADE: Address;
+declare const CREDIT_ACCOUNT: Address;
+declare const WALLET: Address;
+declare const PRICES: Record<Address, bigint>;
+declare const DECIMALS: Record<Address, number>;
+declare const QUOTAS: Record<Address, MockQuotaEntry>;
+declare const LIQUIDATION_THRESHOLDS: Record<Address, number>;
+declare const MAX_DEBT: bigint;
+interface MarketSdkExtras {
+  /** RWA markets: underlying → rwa.asset (`tokensMeta.rwaUnderlyings`). */
+  rwaAssets?: Record<Address, Address>;
+  /** Additional / overriding token prices (PRICE_DECIMALS_POW-scaled). */
+  extraPrices?: Record<Address, bigint>;
+  /** Reserve feed prices; the fixture market has none by default. */
+  reservePrices?: Record<Address, bigint>;
+  /** Additional / overriding token decimals. */
+  extraDecimals?: Record<Address, number>;
+  /** Tokens the registry should report as phantoms. */
+  phantoms?: Address[];
+  /** Facade `minDebt`; 0n when omitted. */
+  minDebt?: bigint;
+  /** Accounts `accounts.getCreditAccountData` answers for. */
+  creditAccounts?: CreditAccountSlice[];
+  /** Redemption venues per source token; omit for a market without any. */
+  delayed?: Record<Address, MockDelayedVenue[]>;
+  /** Quota params replacing the fixture's, e.g. a token with no room left. */
+  quotas?: Record<Address, MockQuotaEntry>;
+  /** Facade pause flag. */
+  facadePaused?: boolean;
+  /** Pool pause flag, which pauses the suite with it. */
+  poolPaused?: boolean;
+  /** Facade expiry in unix seconds; `0` means never. */
+  expirationDate?: number;
+  /** "Now" the expiry is judged against. */
+  timestamp?: number;
+  /** Free liquidity in the pool. */
+  availableLiquidity?: bigint;
+  /** What is left of this manager's debt limit. */
+  debtLimitAvailable?: bigint;
+  /** Per-block borrow cap as a multiple of `maxDebt`; `0` switches it off. */
+  maxDebtPerBlockMultiplier?: number;
+  /** Tokens the facade forbids. */
+  forbiddenTokens?: Address[];
+}
+/** Mock SDK on the shared fixture market. */
+declare function buildMarketSdk(extras?: MarketSdkExtras): OnchainSDK;
+/** Converts an amount to UND at fixture prices (mirrors the mock oracle). */
+declare function valueInUnd(amount: bigint, token: Address, overrides?: {
+  prices?: Record<Address, bigint>;
+  decimals?: Record<Address, number>;
+}): bigint;
+/** Token entry for a fixture CA, with quota defaulting to zero. */
+declare function caToken(token: Address, balance: bigint, quota?: bigint): CreditAccountSlice["tokens"][number];
+/** Bare CA slice on the fixture market. */
+declare function buildFixtureCreditAccount(args: {
+  accountDebt: bigint;
+  tokens: CreditAccountSlice["tokens"];
+}): CreditAccountSlice;
+//#endregion
+export { ANY, MarketSdkExtras, RWA_ASSET, UND, caToken };