@gearbox-protocol/sdk 15.1.0-next.1 → 15.1.0-next.11

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

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,73 @@ 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[];
   /**
-   * Close resume: router `findBestClosePath` result. When set, the mock
-   * provides `routerFor` and `assembleCloseCreditAccountCalls`.
+   * 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.
    */
-  closePath?: {
+  delayed?: Record<Address, MockDelayedVenue[]>;
+  /**
+   * Accounts `accounts.getCreditAccountData` knows, keyed by address. What the
+   * simulate layer reads on its own instead of taking a slice from the caller;
+   * `accountDebt` lands as the principal with no interest or fees accrued.
+   */
+  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 +135,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,107 @@
+import { ClaimableWithdrawal, DelayedDecreaseLeverageIntent } 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 };