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

package/dist/types/sdk/accounts/intents/testing/sdk-mock.d.ts

@@ -1,5 +1,6 @@
 import { MultiCall } from "../../../types/transactions.js";
 import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice } from "../types.js";
 import "../../../index.js";
 import { Address } from "viem";
 //#region src/sdk/accounts/intents/testing/sdk-mock.d.ts
@@ -9,19 +10,21 @@ import { Address } from "viem";
  * The service resolves all market data through `OnchainSDK`
  * (`marketRegister`, `tokensMeta`, `accounts`). `buildMockSdk` builds a mock
  * from plain records; assemble mocks ECHO recognizable sentinel calls derived
- * from their inputs, so `result.instant.calls` pins down which ops reached the
+ * from their inputs, so `result.calls` pins down which ops reached the
  * assembler and in which order.
  */
-/** Fixture `claimableWithdrawal.claimCalls` content; echoes through claim ops. */
-declare const MOCK_CLAIM_CALL: MultiCall;
-/** Recognizable router call embedded in close path results. */
+/** Recognizable router call embedded in routed leg results. */
 declare const MOCK_ROUTER_CALL: MultiCall;
+/** Router call of the many-to-one leg an exit routes. */
+declare const MOCK_CLOSE_CALL: MultiCall;
 /** Returned by the `getRWAWrapCalls` mock; passes through per wrap op. */
 declare const MOCK_RWA_WRAP_CALL: MultiCall;
 /** Router-produced call for an RWA underlying → asset unwrap leg. */
 declare const MOCK_RWA_UNWRAP_CALL: MultiCall;
-/** Returned by the `assembleCloseCreditAccountCalls` mock. */
-declare const MOCK_CLOSE_CALL: MultiCall;
+/** Fixture `claimableWithdrawal.claimCalls` content; echoes through claim ops. */
+declare const MOCK_CLAIM_CALL: MultiCall;
+/** Fixture `requestableWithdrawal.requestCalls`; echoes through request ops. */
+declare const MOCK_REQUEST_CALL: MultiCall;
 /** One sentinel call per plain encodable op type. */
 declare const CA_OP_CALLS: {
   readonly addCollateral: {
@@ -56,28 +59,78 @@ interface MockQuotaEntry {
 interface BuildMockSdkArgs {
   /** Price per token (PRICE_DECIMALS_POW-scaled), like legacy `prices`. */
   prices: Record<Address, bigint>;
+  /** Reserve feed price per token; a token omitted here has no reserve feed. */
+  reservePrices?: Record<Address, bigint>;
   /** Token decimals; used by `tokensMeta` and the price conversion. */
   decimals: Record<Address, number>;
   /** Pool quota params (AddressMap values shape). */
   quotas: Record<Address, MockQuotaEntry>;
   liquidationThresholds: Record<Address, number>;
   maxDebt: bigint;
+  /** Facade `minDebt`; defaults to 0n so debt-range checks stay opt-in. */
+  minDebt?: bigint;
+  /** Pool base rate in ray; feeds `calcBorrowApy` of position metrics. */
+  baseInterestRate?: bigint;
+  /** Credit manager interest fee in Bps; feeds position metrics. */
+  feeInterest?: number;
   creditManager: Address;
   creditFacade: Address;
   /** Market underlying token (`market.pool.underlying`). */
   underlying: Address;
+  /** RWA markets: underlying → rwa.asset (`tokensMeta.rwaUnderlyings`). */
+  rwaAssets?: Record<Address, Address>;
+  /** Tokens reported as phantoms by `tokensMeta.get(...).contractType`. */
+  phantoms?: Address[];
+  /** Facade pause flag, which the suite reports as `isPaused`. */
+  facadePaused?: boolean;
+  /** Pool pause flag, which pauses the suite with it. */
+  poolPaused?: boolean;
+  /** Facade expiry in unix seconds; `0` (the default) means never. */
+  expirationDate?: number;
+  /** "Now" the expiry is judged against; `sdk.timestamp` in the real thing. */
+  timestamp?: number;
+  /** Free liquidity in the pool; defaults to more than any fixture borrows. */
+  availableLiquidity?: bigint;
+  /** What is left of this manager's debt limit in the pool. */
+  debtLimitAvailable?: bigint;
+  /** Per-block borrow cap as a multiple of `maxDebt`; `0` switches it off. */
+  maxDebtPerBlockMultiplier?: number;
+  /** Tokens the facade forbids, which the mock turns into its mask. */
+  forbiddenTokens?: Address[];
+  /**
+   * Single strategy target of this mock credit manager. Defaults to the first
+   * non-underlying collateral so the 1-to-1 CM rule has something to read.
+   */
+  strategyTargetCollateral?: Address;
+  /**
+   * Redemption venues the mock compressor reports, keyed by source token. An
+   * empty array stands for "this token has no delayed route"; several entries
+   * stand for the ambiguous config the engine refuses.
+   */
+  delayed?: Record<Address, MockDelayedVenue[]>;
   /**
-   * Close resume: router `findBestClosePath` result. When set, the mock
-   * provides `routerFor` and `assembleCloseCreditAccountCalls`.
+   * Accounts `accounts.getCreditAccountData` knows, keyed by address. What the
+   * prepare layer reads on its own instead of taking a slice from the caller;
+   * `accountDebt` lands as the principal with no interest or fees accrued.
    */
-  closePath?: {
+  creditAccounts?: CreditAccountSlice[];
+}
+/** One redemption venue of the mock compressor. */
+interface MockDelayedVenue {
+  withdrawalPhantomToken: Address;
+  /** Claim target; defaults to the market underlying. */
+  underlying?: Address;
+  /**
+   * What the request produces. Defaults to the whole `amount` as a delayed
+   * output on the phantom token, i.e. a venue with no instant liquidity.
+   */
+  outputs?: (amount: bigint) => Array<{
+    token: Address;
     amount: bigint;
-    minAmount: bigint;
-    underlyingBalance: bigint;
-    calls: MultiCall[];
-  };
-  /** RWA markets: underlying → rwa.asset (`tokensMeta.rwaUnderlyings`). */
-  rwaAssets?: Record<Address, Address>;
+    isDelayed: boolean;
+  }>;
+  /** Unix seconds reported as `claimableAt`. */
+  claimableAt?: bigint;
 }
 /**
  * Mock `OnchainSDK` covering exactly what the intent-service touches:
@@ -87,4 +140,4 @@ interface BuildMockSdkArgs {
  */
 declare function buildMockSdk(args: BuildMockSdkArgs): OnchainSDK;
 //#endregion
-export { CA_OP_CALLS, MOCK_CLAIM_CALL, MOCK_CLOSE_CALL, MOCK_ROUTER_CALL, MOCK_RWA_UNWRAP_CALL, MOCK_RWA_WRAP_CALL, MockQuotaEntry, buildMockSdk };
+export { MockDelayedVenue, MockQuotaEntry };

package/dist/types/sdk/accounts/intents/tests/add-collateral.fixtures.d.ts

@@ -0,0 +1,45 @@
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { AddCollateralIntent, CreditAccountSlice } from "../types.js";
+import "../../../index.js";
+import { ExpectedFlowOp } from "../testing/expect.js";
+import { caToken } from "../testing/market.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/tests/add-collateral.fixtures.d.ts
+declare const LT_ANY = 9200n;
+/** 1000 UND of pre-existing collateral, 500 UND of debt. */
+declare const BASE_UND = 100000000000n;
+declare const DEBT = 50000000000n;
+/** 2000 ANY = 1000 UND at fixture prices. */
+declare const ADD_ANY = 2000000000000000000000n;
+/** 500 UND. */
+declare const ADD_UND = 50000000000n;
+/** 1000 RWA_ASSET = 1000 UND at fixture prices. */
+declare const ADD_RWA = 100000000000n;
+declare const QUOTA_ANY: bigint;
+declare const QUOTA_RWA: bigint;
+interface AddCollateralCase {
+  intent: AddCollateralIntent;
+  /** Balances already on the account. */
+  tokens: ReturnType<typeof caToken>[];
+  accountDebt: bigint;
+  /** Expected TVL in UND after the operation. */
+  totalValue: bigint;
+  ops: ExpectedFlowOp[];
+  rwaAssets?: Record<Address, Address>;
+}
+/** Position token with a quota: addCollateral then buy quota for it. */
+declare const case_position_token: AddCollateralCase;
+/** Underlying has no quota, so the flow is a bare addCollateral. */
+declare const case_underlying: AddCollateralCase;
+/** RWA market: the rwa asset is deposited as-is, with no wrap leg. */
+declare const case_rwa_asset: AddCollateralCase;
+declare function buildAddCollateralSdk(c: AddCollateralCase): OnchainSDK;
+declare function buildAddCollateralProps(c: AddCollateralCase, sdk: OnchainSDK): {
+  intent: AddCollateralIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  slippage: undefined;
+};
+//#endregion
+export { ADD_ANY, ADD_RWA, ADD_UND, AddCollateralCase, BASE_UND, DEBT, LT_ANY, QUOTA_ANY, QUOTA_RWA, buildAddCollateralProps, buildAddCollateralSdk, case_position_token, case_rwa_asset, case_underlying };

package/dist/types/sdk/accounts/intents/tests/adjust-leverage.fixtures.d.ts

@@ -0,0 +1,56 @@
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { AdjustLeverageIntent, CreditAccountSlice } from "../types.js";
+import "../../../index.js";
+import { ExpectedFlowOp } from "../testing/expect.js";
+import { caToken } from "../testing/market.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/tests/adjust-leverage.fixtures.d.ts
+/** 500 UND. */
+declare const STEP = 50000000000n;
+/** 1000 UND. */
+declare const TVL_2X = 100000000000n;
+/** 1500 UND. */
+declare const TVL_3X = 150000000000n;
+declare const DEBT_2X = 50000000000n;
+declare const DEBT_3X = 100000000000n;
+/** Leverage targets in LEVERAGE_DECIMALS (100n = 1x). */
+declare const LEV_2X = 200n;
+declare const LEV_3X = 300n;
+declare const QUOTA_1000: bigint;
+declare const QUOTA_1500: bigint;
+/** Quota ops carry signed deltas. */
+declare const QUOTA_UP: bigint;
+declare const QUOTA_DOWN: bigint;
+interface AdjustLeverageCase {
+  intent: AdjustLeverageIntent;
+  tokens: ReturnType<typeof caToken>[];
+  accountDebt: bigint;
+  totalValue: bigint;
+  accountDebtAfter: bigint;
+  ops: ExpectedFlowOp[];
+  rwaAssets?: Record<Address, Address>;
+}
+/** 2x → 3x: borrow the difference and buy the position token with it. */
+declare const case_increase: AdjustLeverageCase;
+/** Position token is the underlying: borrowing alone reaches the target. */
+declare const case_increase_underlying: AdjustLeverageCase;
+/** RWA market: the borrowed wrapper is unwrapped instead of swapped. */
+declare const case_increase_rwa: AdjustLeverageCase;
+/** 3x → 2x: sell position token, repay with the proceeds. */
+declare const case_decrease: AdjustLeverageCase;
+/** Idle underlying already covers the repayment, so no swap leg is built. */
+declare const case_decrease_from_idle_underlying: AdjustLeverageCase;
+/** RWA market: the asset is wrapped back into the underlying to repay. */
+declare const case_decrease_rwa: AdjustLeverageCase;
+/** Target equals the current leverage: nothing to do. */
+declare const case_noop: AdjustLeverageCase;
+declare function buildAdjustLeverageSdk(c: AdjustLeverageCase): OnchainSDK;
+declare function buildAdjustLeverageProps(c: AdjustLeverageCase, sdk: OnchainSDK): {
+  intent: AdjustLeverageIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  slippage: undefined;
+};
+//#endregion
+export { AdjustLeverageCase, DEBT_2X, DEBT_3X, LEV_2X, LEV_3X, QUOTA_1000, QUOTA_1500, QUOTA_DOWN, QUOTA_UP, STEP, TVL_2X, TVL_3X, buildAdjustLeverageProps, buildAdjustLeverageSdk, case_decrease, case_decrease_from_idle_underlying, case_decrease_rwa, case_increase, case_increase_rwa, case_increase_underlying, case_noop };

package/dist/types/sdk/accounts/intents/tests/deposit.fixtures.d.ts

@@ -0,0 +1,64 @@
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice, DepositStrategyIntent } from "../types.js";
+import "../../../index.js";
+import { ExpectedFlowOp } from "../testing/expect.js";
+import { caToken } from "../testing/market.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/tests/deposit.fixtures.d.ts
+/** 500 UND. */
+declare const DEP = 50000000000n;
+declare const P1000 = 100000000000n;
+declare const P2000 = 200000000000n;
+declare const P3000 = 300000000000n;
+declare const DEBT_START = 50000000000n;
+declare const QUOTA_1000: bigint;
+declare const QUOTA_2000: bigint;
+declare const QUOTA_3000: bigint;
+declare const LEV_3X = 300n;
+interface DepositCase {
+  intent: DepositStrategyIntent;
+  tokens: ReturnType<typeof caToken>[];
+  accountDebt: bigint;
+  totalValue: bigint;
+  accountDebtAfter: bigint;
+  ops: ExpectedFlowOp[];
+  rwaAssets?: Record<Address, Address>;
+}
+/** 1.1 — leverage preserved: deposit 500, borrow 500, buy 1000 of the position. */
+declare const case_fixed_leverage: DepositCase;
+/** 1.2 — deposit and lever up to 3x in one shot. */
+declare const case_target_leverage: DepositCase;
+/** Position is the underlying itself: borrow and stop, nothing to convert. */
+declare const case_position_is_underlying: DepositCase;
+/** RWA market: the unwrapped asset is deposited, wrapped, then routed. */
+declare const case_rwa_collateral: DepositCase;
+/**
+ * RWA market where the position token is the asset itself: the deposit stays put
+ * and only the borrowed underlying is unwrapped.
+ */
+declare const case_rwa_position: DepositCase;
+/** Matrix baseline: 10A of position against 8U of debt (2U collateral at 5x). */
+declare const M32_BALANCE = 1000000000n;
+declare const M32_DEBT = 800000000n;
+/** 1U deposited, paid in the native coin. */
+declare const M32_DEP = 100000000n;
+/** Proportional debt drawn: D0 * a / C0 = 4U. */
+declare const M32_DD = 400000000n;
+/** Native coin value attached to the addCollateral call (18 decimals). */
+declare const NATIVE_VALUE = 1000000000000000000n;
+/**
+ * Matrix 3.2 — deposit 1U paid in the native coin at preserved 5x. The
+ * position token defaults to the fattest balance (`POS`); `value` rides on
+ * the addCollateral op.
+ */
+declare const case_native_coin: DepositCase;
+declare function buildDepositSdk(c: DepositCase): OnchainSDK;
+declare function buildDepositProps(c: DepositCase, sdk: OnchainSDK): {
+  intent: DepositStrategyIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  slippage: undefined;
+};
+//#endregion
+export { DEBT_START, DEP, DepositCase, LEV_3X, M32_BALANCE, M32_DD, M32_DEBT, M32_DEP, NATIVE_VALUE, P1000, P2000, P3000, QUOTA_1000, QUOTA_2000, QUOTA_3000, buildDepositProps, buildDepositSdk, case_fixed_leverage, case_native_coin, case_position_is_underlying, case_rwa_collateral, case_rwa_position, case_target_leverage };

package/dist/types/sdk/accounts/intents/tests/finish-decrease-leverage.fixtures.d.ts

@@ -0,0 +1,109 @@
+import { DelayedDecreaseLeverageIntent } from "../../../../model/delayed-intents.js";
+import "../../../../model/index.js";
+import { ClaimableWithdrawal } from "../../withdrawal-compressor/types.js";
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice } from "../types.js";
+import "../../../index.js";
+import { ExpectedFlowOp } from "../testing/expect.js";
+import { ANY, RWA_ASSET, UND } from "../testing/market.js";
+import "../testing/delayed.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/tests/finish-decrease-leverage.fixtures.d.ts
+/**
+ * Decrease-leverage tail fixtures, ported from intent-calculator
+ * `decreaseLeverage.flowFixtures.ts` (tail cases only).
+ */
+/** Repay for L0 → L1_FOUR with fixed collateral. */
+declare const DECREASE_REPAY = 1000000000000n;
+/** CA ANY spent to fund {@link DECREASE_REPAY} (oracle: ANY@$1 → UND@$2). */
+declare const DECREASE_AMOUNT_S = 20000000000000000000000n;
+/** Post-claim metrics after claim repay (fixed C). */
+declare const DECREASE_POST_T = 4000000000000n;
+declare const DECREASE_POST_D = 3000000000000n;
+/** Pre-repay account debt (D0). */
+declare const DECREASE_PRE_D: bigint;
+/** Pre-repay TVL with claim proceeds still on CA (T0). */
+declare const DECREASE_PRE_T: bigint;
+declare const PHANTOM: Address;
+declare function buildDecreaseSdk(args: {
+  claimedToken: Address;
+  rwaAssets?: Record<Address, Address>;
+}): OnchainSDK;
+/** The matured withdrawal these fixtures claim. */
+declare function buildDecreaseClaimable(args: {
+  claimedToken: Address;
+  claimedAmount: bigint;
+}): ClaimableWithdrawal;
+declare function buildDecreaseTailProps(args: {
+  claimedToken: Address;
+  claimedAmount: bigint;
+  sdk: OnchainSDK;
+  slippage?: number;
+  /**
+   * Extra CA balances besides the withdrawal phantom. Defaults so that after
+   * claim the TVL equals {@link DECREASE_PRE_T} (post-repay →
+   * {@link DECREASE_POST_T}).
+   */
+  tokens?: CreditAccountSlice["tokens"];
+}): {
+  intent: DelayedDecreaseLeverageIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  claimable: ClaimableWithdrawal;
+  slippage: number;
+};
+/** Convenience: props for a claimed token/amount. */
+declare function buildDecreaseOnchainTailProps(args: {
+  claimedToken: Address;
+  claimedAmount: bigint;
+  rwaAssets?: Record<Address, Address>;
+  slippage?: number;
+}): {
+  intent: DelayedDecreaseLeverageIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  claimable: ClaimableWithdrawal;
+  slippage: number;
+};
+/** Matrix baseline debt: 8U. */
+declare const M7_DEBT = 800000000n;
+/** Delayed deleverage 5x → 3x repays 4U. */
+declare const M7_DD = 400000000n;
+/** Position left after the leading half redeemed 4A of the 10A. */
+declare const M7_POS_LEFT = 600000000n;
+/** 4U claimed in `ANY` (priced 1 against `UND` priced 2): 8 ANY. */
+declare const M7_CLAIM_ANY = 8000000000000000000n;
+/** Quotable withdrawal phantom: `POS2`, 1:1 with `POS`. */
+declare const M7_PHANTOM: `0x${string}`;
+interface MatrixDecreaseTailCase {
+  claimedToken: Address;
+  claimedAmount: bigint;
+  totalValue: bigint;
+  ops: ExpectedFlowOp[];
+}
+/** Matrix 7.2 tail — the claim pays `UND`; everything claimed repays the debt. */
+declare const case_matrix_7_2_tail: MatrixDecreaseTailCase;
+/**
+ * Matrix 7.3 tail — the claim pays `ANY`, swapped into `UND` before repaying.
+ * The swap output (`amountOut`) comes from the router quote, which the spec
+ * mocks to a realistic 1:1-in-value path — the echo router would otherwise
+ * repay its raw input as debt (same override as case D above).
+ */
+declare const case_matrix_7_3_tail: MatrixDecreaseTailCase;
+/**
+ * Props for a matrix decrease-leverage tail: the account as the delayed
+ * deleverage to 3x left it — 6A of position and 4A of phantom — plus the
+ * matured claim.
+ */
+declare function buildMatrixDecreaseTailProps(c: MatrixDecreaseTailCase): {
+  intent: DelayedDecreaseLeverageIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  claimable: ClaimableWithdrawal;
+  slippage: undefined;
+};
+//#endregion
+export { ANY, DECREASE_AMOUNT_S, DECREASE_POST_D, DECREASE_POST_T, DECREASE_PRE_D, DECREASE_PRE_T, DECREASE_REPAY, M7_CLAIM_ANY, M7_DD, M7_DEBT, M7_PHANTOM, M7_POS_LEFT, MatrixDecreaseTailCase, PHANTOM, RWA_ASSET, UND, buildDecreaseClaimable, buildDecreaseOnchainTailProps, buildDecreaseSdk, buildDecreaseTailProps, buildMatrixDecreaseTailProps, case_matrix_7_2_tail, case_matrix_7_3_tail };

package/dist/types/sdk/accounts/intents/tests/finish-withdraw.fixtures.d.ts

@@ -0,0 +1,138 @@
+import { DelayedWithdrawCollateralIntent } from "../../../../model/delayed-intents.js";
+import "../../../../model/index.js";
+import { ClaimableWithdrawal } from "../../withdrawal-compressor/types.js";
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice } from "../types.js";
+import "../../../index.js";
+import { ExpectedFlowOp } from "../testing/expect.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/tests/finish-withdraw.fixtures.d.ts
+/**
+ * Withdraw tail fixtures, ported from intent-calculator
+ * `withdraw.flowFixtures.ts` (tail cases only).
+ */
+declare const WITHDRAW_UND: bigint;
+declare const WITHDRAW_ANY: bigint;
+declare const WITHDRAW_ANY2: bigint;
+/** Withdraw amount in rwa.asset units (8 decimals, priced 1:1 with UND). */
+declare const WITHDRAW_RWA: bigint;
+declare const DEBT_DELTA: bigint;
+declare const PHANTOM: Address;
+/** Per-token CA balance (legacy `A0_TOK` / und balance). */
+declare const A0: bigint;
+declare const A0_UND: bigint;
+declare const QUOTA0: bigint;
+/** Starting account debt on the fixture CA. */
+declare const WITHDRAW_PRE_D: bigint;
+/**
+ * Starting TVL of the fixture CA tokens (ANY + ANY2 + UND). Claim may add
+ * value when the phantom is absent from `tokens` (current fixtures).
+ */
+declare const WITHDRAW_BASE_TV = 20000000000000n;
+declare const WITHDRAW_TO: Address;
+declare function withdrawAmountFor(token: Address): bigint;
+declare function buildWithdrawSdk(args: {
+  claimedToken: Address;
+  extraPrices?: Record<Address, bigint>;
+  extraDecimals?: Record<Address, number>;
+  rwaAssets?: Record<Address, Address>;
+}): OnchainSDK;
+/** The matured withdrawal these fixtures claim. */
+declare function buildWithdrawClaimable(args: {
+  claimedToken: Address;
+  claimedAmount: bigint;
+}): ClaimableWithdrawal;
+declare function buildWithdrawFinishProps(args: {
+  sourceToken: Address;
+  withdrawToken: Address;
+  claimedToken: Address;
+  claimedAmount: bigint;
+  debtRepaid: bigint;
+  sdk: OnchainSDK;
+  /** Overrides `withdrawAmountFor(withdrawToken)` when set. */
+  withdrawAmount?: bigint;
+  tokens?: CreditAccountSlice["tokens"];
+  slippage?: number;
+}): {
+  intent: DelayedWithdrawCollateralIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  claimable: ClaimableWithdrawal;
+  slippage: number;
+};
+/** Matrix baseline debt: 8U. */
+declare const M4_DEBT = 800000000n;
+/** Matrix payout W: 1U. */
+declare const M4_W = 100000000n;
+/** Proportional repayment `dD = D0 * W / C0` = 4U. */
+declare const M4_DD = 400000000n;
+/** Payout plus repayment: 5U redeemed by the leading half. */
+declare const M4_SPEND: bigint;
+/** Quotable withdrawal phantom: `POS2`, 1:1 with `POS`. */
+declare const M4_PHANTOM: `0x${string}`;
+/** 5U claimed in `ANY` (priced 1 against `UND` priced 2): 10 ANY. */
+declare const M4_CLAIM_ANY = 10000000000000000000n;
+/** TVL the 4.4/4.6 tails report — the echo router credits its raw input. */
+declare const M4_ECHO_TVL = 10000000000000000000n;
+interface MatrixWithdrawTailCase {
+  claimedToken: Address;
+  claimedAmount: bigint;
+  totalValue: bigint;
+  ops: ExpectedFlowOp[];
+  rwaAssets?: Record<Address, Address>;
+}
+/**
+ * Matrix 4.3 tail — the claim pays `UND` directly.
+ *
+ * MATRIX MISMATCH: the matrix pays out first — `claim →
+ * withdrawCollateral(min(W, claim.amount)) → decreaseDebt(rest) →
+ * changeQuota`. The engine repays before paying out (`repay(debtRepaid,
+ * keep: W)` precedes the payout leg in `planFinishWithdraw`):
+ * `claim → decreaseDebt(dD) → withdrawCollateral(W) → changeQuota`.
+ * Amounts are identical; only the order differs.
+ */
+declare const case_matrix_4_3_tail: MatrixWithdrawTailCase;
+/**
+ * Matrix 4.4 tail — the claim pays `ANY`, routed into `UND` first.
+ *
+ * MATRIX MISMATCH: same ordering divergence as 4.3 — the matrix expects
+ * `claim → swap → withdrawCollateral → decreaseDebt → changeQuota`, the
+ * engine repays first:
+ * `claim → swap → decreaseDebt → withdrawCollateral → changeQuota`.
+ */
+declare const case_matrix_4_4_tail: MatrixWithdrawTailCase;
+/**
+ * Matrix 4.5 tail — 4.3 on the RWA market: unwrap before the payout.
+ *
+ * MATRIX MISMATCH: same ordering divergence as 4.3 — the matrix expects
+ * `claim → unwrapRwaCollateral → withdrawCollateral(RWA) → decreaseDebt →
+ * changeQuota`, the engine repays first:
+ * `claim → decreaseDebt → unwrapRwaCollateral → withdrawCollateral(RWA) →
+ * changeQuota`.
+ */
+declare const case_matrix_4_5_tail: MatrixWithdrawTailCase;
+/**
+ * Matrix 4.6 tail — 4.4 on the RWA market.
+ *
+ * MATRIX MISMATCH: same ordering divergence as 4.3 — the matrix expects
+ * `claim → swap → unwrapRwaCollateral → withdrawCollateral(RWA) →
+ * decreaseDebt → changeQuota`, the engine repays first:
+ * `claim → swap → decreaseDebt → unwrapRwaCollateral →
+ * withdrawCollateral(RWA) → changeQuota`.
+ */
+declare const case_matrix_4_6_tail: MatrixWithdrawTailCase;
+/**
+ * Props for a matrix withdraw tail: the account as the 4.3 start left it —
+ * 5A of position and 5A of phantom — plus the matured claim.
+ */
+declare function buildMatrixWithdrawTailProps(c: MatrixWithdrawTailCase): {
+  intent: DelayedWithdrawCollateralIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  claimable: ClaimableWithdrawal;
+  slippage: undefined;
+};
+//#endregion
+export { A0, A0_UND, DEBT_DELTA, M4_CLAIM_ANY, M4_DD, M4_DEBT, M4_ECHO_TVL, M4_PHANTOM, M4_SPEND, M4_W, MatrixWithdrawTailCase, PHANTOM, QUOTA0, WITHDRAW_ANY, WITHDRAW_ANY2, WITHDRAW_BASE_TV, WITHDRAW_PRE_D, WITHDRAW_RWA, WITHDRAW_TO, WITHDRAW_UND, buildMatrixWithdrawTailProps, buildWithdrawClaimable, buildWithdrawFinishProps, buildWithdrawSdk, case_matrix_4_3_tail, case_matrix_4_4_tail, case_matrix_4_5_tail, case_matrix_4_6_tail, withdrawAmountFor };

package/dist/types/sdk/accounts/intents/tests/open-strategy.fixtures.d.ts

@@ -0,0 +1,56 @@
+import { Asset } from "../../../base/types.js";
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { OpenStrategyProps } from "../open-strategy.js";
+import "../../../index.js";
+import { MarketSdkExtras } from "../testing/market.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/tests/open-strategy.fixtures.d.ts
+/**
+ * Open-strategy fixtures.
+ *
+ * `POS` is the target throughout: it is 1:1 with `UND`, so the mock router's
+ * oracle-priced output stays readable while the `ANY` leg (18 decimals, half the
+ * price) still exercises the rescaling.
+ */
+declare const LT = 9200n;
+/** Quota bought for a projected balance: value in UND scaled by its LT. */
+declare function quotaFor(amount: bigint, token: Address): bigint;
+/** 1000 UND of margin. */
+declare const MARGIN_UND: bigint;
+/** 500 UND. */
+declare const HALF_UND: bigint;
+/** 1000 ANY = 500 UND at fixture prices. */
+declare const COLLATERAL_ANY: bigint;
+/** ANY balance to keep unswapped: 400 ANY = 200 UND. */
+declare const KEEP_ANY: bigint;
+declare const LEVERAGE_1X = 100n;
+declare const LEVERAGE_2X = 200n;
+declare const LEVERAGE_3X = 300n;
+interface OpenStrategyCase {
+  collateral: Asset[];
+  targetToken: Address;
+  leverage: bigint;
+  leftoverBalances?: Asset[];
+  /** Margin in UND. */
+  expectedCollateral: bigint;
+  expectedDebt: bigint;
+  /** Balances the account should hold once the path executes. */
+  expectedAssets: Asset[];
+  /** Balances the router should be asked to route (collateral + debt). */
+  expectedRouterBalances: Asset[];
+}
+/** Plain 3x on underlying margin: everything routes into the position token. */
+declare const case_underlying_3x: OpenStrategyCase;
+/** 1x — no loan at all, just a spot conversion of the margin. */
+declare const case_underlying_1x: OpenStrategyCase;
+/**
+ * Mixed margin with a leftover: 500 UND + 1000 ANY (= 500 UND) at 2x.
+ *
+ * 400 ANY stays put, so only 600 ANY (= 300 UND) plus the whole 1500 UND is
+ * routed, and the kept ANY needs a quota of its own.
+ */
+declare const case_mixed_with_leftover: OpenStrategyCase;
+declare function buildOpenStrategySdk(extras?: MarketSdkExtras): OnchainSDK;
+declare function buildOpenStrategyProps(c: OpenStrategyCase, sdk: OnchainSDK): OpenStrategyProps;
+//#endregion
+export { COLLATERAL_ANY, HALF_UND, KEEP_ANY, LEVERAGE_1X, LEVERAGE_2X, LEVERAGE_3X, LT, MARGIN_UND, OpenStrategyCase, buildOpenStrategyProps, buildOpenStrategySdk, case_mixed_with_leftover, case_underlying_1x, case_underlying_3x, quotaFor };

package/dist/types/sdk/accounts/intents/tests/withdraw-asset.fixtures.d.ts

@@ -0,0 +1,60 @@
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice, WithdrawAssetIntent } from "../types.js";
+import "../../../index.js";
+import { ExpectedFlowOp } from "../testing/expect.js";
+import { caToken } from "../testing/market.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/tests/withdraw-asset.fixtures.d.ts
+/**
+ * Start withdraw-asset fixtures (intent 4), covering the cases from the spec's
+ * "withdraw collateral intent" section.
+ *
+ * Debt never moves, so every case is `withdrawCollateral` plus the quota
+ * decrease implied by the smaller balance. The one branch is the RWA market
+ * forced unwrap when the withdrawn token is the wrapped underlying.
+ */
+declare const LT_ANY = 9200n;
+/** 2000 ANY = 1000 UND at fixture prices. */
+declare const HELD_ANY = 2000000000000000000000n;
+/** 1000 UND. */
+declare const HELD_UND = 100000000000n;
+declare const DEBT = 50000000000n;
+/** Half the ANY position. */
+declare const OUT_ANY = 1000000000000000000000n;
+/**
+ * 300 of the 1000 UND held. Not half: the underlying is weighted at 98% in this
+ * fixture, so leaving 500 against 500 of debt would end below water and the
+ * facade would refuse the withdrawal.
+ */
+declare const OUT_UND = 30000000000n;
+declare const QUOTA_ANY_BEFORE: bigint;
+declare const QUOTA_ANY_AFTER: bigint;
+/** Quota ops carry signed deltas, so a release is negative. */
+declare const QUOTA_ANY_DELTA: bigint;
+interface WithdrawAssetCase {
+  intent: WithdrawAssetIntent;
+  tokens: ReturnType<typeof caToken>[];
+  accountDebt: bigint;
+  totalValue: bigint;
+  ops: ExpectedFlowOp[];
+  rwaAssets?: Record<Address, Address>;
+}
+/** Quota token out: withdraw, then release the freed quota. */
+declare const case_any_token: WithdrawAssetCase;
+/** Underlying out on a plain market: no quota, no unwrap. */
+declare const case_underlying: WithdrawAssetCase;
+/**
+ * Underlying out on an RWA market: the wrapper cannot leave the account, so it
+ * is force-unwrapped and the rwa asset is withdrawn instead.
+ */
+declare const case_rwa_underlying: WithdrawAssetCase;
+declare function buildWithdrawAssetSdk(c: WithdrawAssetCase): OnchainSDK;
+declare function buildWithdrawAssetProps(c: WithdrawAssetCase, sdk: OnchainSDK): {
+  intent: WithdrawAssetIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  slippage: undefined;
+};
+//#endregion
+export { DEBT, HELD_ANY, HELD_UND, LT_ANY, OUT_ANY, OUT_UND, QUOTA_ANY_AFTER, QUOTA_ANY_BEFORE, QUOTA_ANY_DELTA, WithdrawAssetCase, buildWithdrawAssetProps, buildWithdrawAssetSdk, case_any_token, case_rwa_underlying, case_underlying };