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

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

@@ -0,0 +1,207 @@
+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. An exit records {@link planFinishCloseAccount}'s intent
+ * instead, and rebuilds itself from the account rather than from the request.
+ */
+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[];
+/**
+ * The tail of an exit: the claim lands, everything the account holds is sold
+ * into the underlying, the loan is settled out of the proceeds and the rest
+ * goes to the wallet. The account survives it, empty and owing nothing.
+ *
+ * Nothing is quoted from the request — the same shape {@link planWithdraw}
+ * builds for an instant exit is rebuilt here against the account as it stands
+ * now, which is the only state that can name these amounts.
+ */
+declare function planFinishCloseAccount(intent: {
+  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, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };

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

@@ -0,0 +1,42 @@
+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";
+import { RouterPaths } from "./utils/router-path.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;
+  /**
+   * Where routed legs are quoted. Defaults to the pathfinder, which is what
+   * anything that will be sent needs; a walk that only projects a state passes
+   * `createOraclePaths` instead.
+   */
+  paths?: RouterPaths;
+}
+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/tail.d.ts

@@ -0,0 +1,52 @@
+import { ClaimableWithdrawal } from "../withdrawal-compressor/types.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { CreditAccountSlice, DelayedStart, OperationState, ResumableIntent } from "./types.js";
+import { AccountCalculatorOperation, StartDelayedWithdrawalOperation } from "./operations.js";
+import "../../index.js";
+import { AccountView, Step } from "./plan.js";
+//#region src/sdk/accounts/intents/tail.d.ts
+/**
+ * The second half of a delayed intent: the claim, then whatever the intent
+ * still owes.
+ *
+ * Shared by the two callers that need it and must not disagree — the tail as
+ * it is previewed days later against the account that really exists, and the
+ * tail as it is projected the moment the request is made.
+ */
+declare function planTail(args: {
+  intent: ResumableIntent;
+  claimable: ClaimableWithdrawal;
+  view: AccountView;
+}): Step[];
+/**
+ * Where a delayed intent ends up, worked out at the moment it is started.
+ *
+ * A request is only half a withdrawal, so the state it lands in is not the
+ * answer to "what does this do to my position": the debt is still there, the
+ * payout has not been made, and the position sits in a phantom token. What the
+ * caller means is the far side — and that side can be walked now, because the
+ * request already fixes the claim it will be finished from.
+ *
+ * So the same tail {@link planTail} builds at claim time is built here against
+ * the account as the request leaves it, with the claim it is expected to bring,
+ * and walked by the same realiser — with one substitution: routed legs are
+ * priced by the oracle rather than the pathfinder, since the funds they trade
+ * do not exist yet and no calldata is being produced. The result is an
+ * estimate that the engine's guards are nevertheless applied to, so a request
+ * that would strand the account is refused before it is sent rather than
+ * discovered days later.
+ */
+declare function projectTail(args: {
+  /** The request as realised: the source spent, the phantom it produced. */
+  request: StartDelayedWithdrawalOperation;
+  delayed: DelayedStart;
+  /** The account the request was previewed against, for masks and market. */
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  quotaReserve: number | undefined;
+}): Promise<{
+  state: OperationState;
+  operations: AccountCalculatorOperation[];
+}>;
+//#endregion
+export { planTail, projectTail };

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,24 @@
+import { TokenAmount } from "../../../../model/primitives.js";
+import "../../../../model/index.js";
 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 +27,22 @@ 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;
-declare function assetBalance(assets: Array<{
-  token: Address;
-  balance: bigint;
-}>, token: Address): bigint;
+}): OperationState;
+/** Asserts the preview failed for a specific reason. */
+declare function expectPreviewError(result: IntentPreviewResult | DelayedStartResult, reason: Extract<IntentPreviewResult, {
+  ok: false;
+}>["reason"]): void;
+/** What a priced holdings list says the account holds of `token`. */
+declare function assetBalance(assets: Array<TokenAmount>, token: Address): bigint;
 //#endregion
 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

@@ -0,0 +1,143 @@
+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
+/**
+ * Test kit for intent-service specs.
+ *
+ * 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.calls` pins down which ops reached the
+ * assembler and in which order.
+ */
+/** 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;
+/** 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: {
+    readonly target: Address;
+    readonly callData: "0x";
+  };
+  readonly increaseDebt: {
+    readonly target: Address;
+    readonly callData: "0x";
+  };
+  readonly decreaseDebt: {
+    readonly target: Address;
+    readonly callData: "0x";
+  };
+  readonly withdrawCollateral: {
+    readonly target: Address;
+    readonly callData: "0x";
+  };
+  readonly changeQuota: {
+    readonly target: Address;
+    readonly callData: "0x";
+  };
+};
+interface MockQuotaEntry {
+  token: Address;
+  rate: bigint;
+  limit: bigint;
+  totalQuoted?: bigint;
+  quotaIncreaseFee?: bigint;
+  isActive: boolean;
+}
+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[]>;
+  /**
+   * 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.
+   */
+  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;
+    isDelayed: boolean;
+  }>;
+  /** Unix seconds reported as `claimableAt`. */
+  claimableAt?: bigint;
+}
+/**
+ * Mock `OnchainSDK` covering exactly what the intent-service touches:
+ * price conversion, quota params, CM/facade lookup and call assembly.
+ * Conversion mirrors the legacy price-based math:
+ * `amount * price[from] * 10^dec(to) / (price[to] * 10^dec(from))`.
+ */
+declare function buildMockSdk(args: BuildMockSdkArgs): OnchainSDK;
+//#endregion
+export { MockDelayedVenue, MockQuotaEntry };