@gearbox-protocol/sdk 15.1.0-next.9 → 16.0.0-next.2

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 };

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

@@ -0,0 +1,79 @@
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice, WithdrawStrategyIntent } 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.fixtures.d.ts
+/** 100 UND of value leaving the account. */
+declare const W = 10000000000n;
+/** Payout plus proportional repayment. */
+declare const SPEND: bigint;
+declare const TVL_BEFORE = 200000000000n;
+declare const DEBT_BEFORE = 100000000000n;
+declare const TVL_AFTER: bigint;
+declare const DEBT_AFTER: bigint;
+declare const QUOTA_BEFORE: bigint;
+declare const QUOTA_AFTER: bigint;
+/** Quota ops carry signed deltas. */
+declare const QUOTA_DELTA: bigint;
+interface WithdrawCase {
+  intent: WithdrawStrategyIntent;
+  tokens: ReturnType<typeof caToken>[];
+  accountDebt: bigint;
+  totalValue: bigint;
+  accountDebtAfter: bigint;
+  ops: ExpectedFlowOp[];
+  rwaAssets?: Record<Address, Address>;
+}
+/** Row 1 — S = U, T = U: repay, then hand over the underlying. */
+declare const case_und_und: WithdrawCase;
+/** Row 2 — S = U, T = POS: repay, then route the payout out of the underlying. */
+declare const case_und_pos: WithdrawCase;
+/** Row 3 — S = POS, T = U: both legs land in the underlying, so one swap covers them. */
+declare const case_pos_und: WithdrawCase;
+/** Row 4 — S = T = POS: only the repayment needs routing. */
+declare const case_pos_pos: WithdrawCase;
+/** Row 5 — S = POS, T = POS2: two independent legs out of the same source. */
+declare const case_pos_pos2: WithdrawCase;
+/** RWA market: the underlying payout is force-unwrapped to the asset. */
+declare const case_rwa_payout: WithdrawCase;
+/** Matrix baseline: 10A of position against 8U of debt (2U collateral at 5x). */
+declare const M4_BALANCE = 1000000000n;
+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 liquidated in total. */
+declare const M4_SPEND: bigint;
+/**
+ * Matrix 4.1 — withdraw 1U, source `POS`, payout `UND`.
+ *
+ * MATRIX MISMATCH: the matrix pays out first — `swap → withdrawCollateral →
+ * decreaseDebt → changeQuota`. The engine repays before paying out
+ * (`repay(dD, keep: W)` precedes the payout leg in `planWithdraw`):
+ * `swap → decreaseDebt → withdrawCollateral → changeQuota`. Amounts are
+ * identical; only the order differs.
+ */
+declare const case_matrix_4_1: WithdrawCase;
+/**
+ * Matrix 4.2 — 4.1 on the RWA market: the payout is unwrapped on the way out.
+ *
+ * MATRIX MISMATCH: same ordering divergence as 4.1 — the matrix expects
+ * `swap → unwrapRwaCollateral → withdrawCollateral(RWA) → decreaseDebt →
+ * changeQuota`, the engine repays first:
+ * `swap → decreaseDebt → unwrapRwaCollateral → withdrawCollateral(RWA) →
+ * changeQuota`.
+ */
+declare const case_matrix_4_2: WithdrawCase;
+declare function buildWithdrawSdk(c: WithdrawCase): OnchainSDK;
+declare function buildWithdrawProps(c: WithdrawCase, sdk: OnchainSDK): {
+  intent: WithdrawStrategyIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  slippage: undefined;
+};
+//#endregion
+export { DEBT_AFTER, DEBT_BEFORE, M4_BALANCE, M4_DD, M4_DEBT, M4_SPEND, M4_W, QUOTA_AFTER, QUOTA_BEFORE, QUOTA_DELTA, SPEND, TVL_AFTER, TVL_BEFORE, W, WithdrawCase, buildWithdrawProps, buildWithdrawSdk, case_matrix_4_1, case_matrix_4_2, case_pos_pos, case_pos_pos2, case_pos_und, case_rwa_payout, case_und_pos, case_und_und };