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

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

@@ -0,0 +1,136 @@
+import { ClaimableWithdrawal, DelayedWithdrawCollateralIntent } 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 };