@gearbox-protocol/sdk 14.12.0-next.69 → 14.12.0-next.70

package/dist/esm/sdk/accounts/intents/index.js

@@ -0,0 +1,387 @@
+import { SDKConstruct } from "../../base/SDKConstruct.js";
+import { assembleOperationCalls } from "./utils/assemble-operation-calls.js";
+import { simulateState } from "./utils/simulate-adjust-state.js";
+import { getOperationsWithQuotaUpdate } from "./utils/with-quota-update.js";
+import "./utils/index.js";
+import { buildResumeAddCollateralOperations } from "./intents/resume/add-collateral/add-collateral.js";
+import { buildResumeCloseOperations } from "./intents/resume/close/close.js";
+import { buildResumeDecreaseLeverageOperations } from "./intents/resume/decrease-leverage/decrease-leverage.js";
+import { buildResumeDepositOperations } from "./intents/resume/deposit/deposit.js";
+import { buildResumeIncreaseLeverageOperations } from "./intents/resume/increase-leverage/increase-leverage.js";
+import { buildResumeWithdrawOperations } from "./intents/resume/withdraw/withdraw.js";
+import "./intents/resume/index.js";
+import { createCloseOracleQuoter, createRouterCloseQuoter } from "./quoters/close.js";
+import { createOracleSwapQuoter, createRouterSwapQuoter } from "./quoters/swap.js";
+import "./quoters/index.js";
+//#region src/sdk/accounts/intents/index.ts
+var CreditAccountOperationsService = class extends SDKConstruct {
+	async finishIntent(props) {
+		const intent = props.intent;
+		switch (intent.type) {
+			case "ADD_COLLATERAL": return this.#finishAddCollateralIntent({
+				...props,
+				intent
+			});
+			case "INCREASE_LEVERAGE": return this.#finishIncreaseLeverageIntent({
+				...props,
+				intent
+			});
+			case "DEPOSIT": return this.#finishDepositIntent({
+				...props,
+				intent
+			});
+			case "DEPOSIT_AND_INCREASE_LEVERAGE": return this.#finishDepositAndIncreaseLeverageIntent({
+				...props,
+				intent
+			});
+			case "CLOSE_ACCOUNT": return this.#finishCloseAccountIntent({
+				...props,
+				intent
+			});
+			case "WITHDRAW_COLLATERAL": return this.#finishWithdrawCollateralIntent({
+				...props,
+				intent
+			});
+			case "DECREASE_LEVERAGE": return this.#finishDecreaseLeverageIntent({
+				...props,
+				intent
+			});
+			default: throw new Error(`${props.intent.type} - not implemented`);
+		}
+	}
+	/**
+	* Shared resume flow for claim-only intents (add collateral, increase
+	* leverage, deposit, deposit+increase): claim op + trailing changeQuota.
+	* If any implementations change, respective handler should be implemented separately
+	*/
+	#finishClaimOnlyIntent = (buildOperations) => async (props) => {
+		switch (props.options.kind) {
+			case "offchain": return this.#finishClaimOnlyIntentOffchain(props, props.options, buildOperations);
+			default: return this.#finishClaimOnlyIntentOnchain(props, props.options, buildOperations);
+		}
+	};
+	#finishClaimOnlyIntentOffchain(props, options, buildOperations) {
+		const baseOperations = buildOperations(props.creditAccount, options, this.sdk);
+		const state = simulateState({
+			...props,
+			operations: baseOperations
+		});
+		return {
+			ok: true,
+			instant: {
+				operations: getOperationsWithQuotaUpdate({
+					operations: baseOperations,
+					state,
+					creditAccount: props.creditAccount,
+					sdk: this.sdk,
+					options
+				}),
+				preview: { min: state.state },
+				calls: []
+			},
+			instantError: void 0,
+			delayedBranch: void 0,
+			delayedError: void 0
+		};
+	}
+	async #finishClaimOnlyIntentOnchain(props, options, buildOperations) {
+		const baseOperations = buildOperations(props.creditAccount, options, this.sdk);
+		const state = simulateState({
+			...props,
+			operations: baseOperations
+		});
+		const operations = getOperationsWithQuotaUpdate({
+			operations: baseOperations,
+			state,
+			creditAccount: props.creditAccount,
+			sdk: this.sdk,
+			options
+		});
+		const calls = await assembleOperationCalls({
+			...props,
+			operations
+		});
+		return {
+			ok: true,
+			instant: {
+				operations,
+				preview: { min: state.state },
+				calls
+			},
+			instantError: void 0,
+			delayedBranch: void 0,
+			delayedError: void 0
+		};
+	}
+	#finishAddCollateralIntent = this.#finishClaimOnlyIntent(buildResumeAddCollateralOperations);
+	#finishIncreaseLeverageIntent = this.#finishClaimOnlyIntent(buildResumeIncreaseLeverageOperations);
+	#finishDepositIntent = this.#finishClaimOnlyIntent(buildResumeDepositOperations);
+	#finishDepositAndIncreaseLeverageIntent = this.#finishClaimOnlyIntent(buildResumeDepositOperations);
+	/**
+	* Resume close: claim, then close against quoted post-claim balances.
+	* Offchain quotes equity by oracle prices, onchain — router close path.
+	* Router miss soft-fails to the oracle quote with `calls: []` (legacy parity).
+	*/
+	async #finishCloseAccountIntent({ options, ...props }) {
+		switch (options.kind) {
+			case "offchain": return this.#finishCloseAccountIntentOffchain({
+				...props,
+				options
+			});
+			default: try {
+				return await this.#finishCloseAccountIntentOnchain({
+					...props,
+					options
+				});
+			} catch {
+				return this.#finishCloseAccountIntentOffchain({
+					...props,
+					options
+				});
+			}
+		}
+	}
+	async #finishCloseAccountIntentOffchain({ options, ...props }) {
+		const quoter = createCloseOracleQuoter({
+			sdk: this.sdk,
+			creditAccount: props.creditAccount
+		});
+		const { operations, quote } = await buildResumeCloseOperations({
+			...props,
+			options
+		}, quoter);
+		return {
+			ok: true,
+			instant: {
+				operations,
+				preview: { min: {
+					kind: "close",
+					amount: quote.amount,
+					minAmount: quote.minAmount,
+					underlyingBalance: quote.underlyingBalance
+				} },
+				calls: []
+			},
+			instantError: void 0,
+			delayedBranch: void 0,
+			delayedError: void 0
+		};
+	}
+	async #finishCloseAccountIntentOnchain({ options, slippage = 0, ...props }) {
+		const quoter = createRouterCloseQuoter({
+			sdk: this.sdk,
+			creditAccount: props.creditAccount,
+			slippage
+		});
+		const { operations, quote } = await buildResumeCloseOperations({
+			...props,
+			options
+		}, quoter);
+		const calls = await assembleOperationCalls({
+			...props,
+			operations
+		});
+		return {
+			ok: true,
+			instant: {
+				operations,
+				preview: { min: {
+					kind: "close",
+					amount: quote.amount,
+					minAmount: quote.minAmount,
+					underlyingBalance: quote.underlyingBalance
+				} },
+				calls
+			},
+			instantError: void 0,
+			delayedBranch: void 0,
+			delayedError: void 0
+		};
+	}
+	/**
+	* Resume withdraw: claim → (swap?) → decreaseDebt? → (unwrapRwa?) →
+	* withdrawCollateral + trailing changeQuota. Offchain prices swaps by
+	* oracle, onchain — router swap paths (leftover-aware).
+	*/
+	async #finishWithdrawCollateralIntent({ options, ...props }) {
+		switch (options.kind) {
+			case "offchain": return this.#finishWithdrawCollateralIntentOffchain({
+				...props,
+				options
+			});
+			default: try {
+				return await this.#finishWithdrawCollateralIntentOnchain({
+					...props,
+					options
+				});
+			} catch {
+				return this.#finishWithdrawCollateralIntentOffchain({
+					...props,
+					options
+				});
+			}
+		}
+	}
+	async #finishWithdrawCollateralIntentOffchain({ options, ...props }) {
+		const quoter = createOracleSwapQuoter({
+			sdk: this.sdk,
+			creditAccount: props.creditAccount
+		});
+		const baseOperations = await buildResumeWithdrawOperations({
+			...props,
+			options
+		}, quoter);
+		const state = simulateState({
+			...props,
+			operations: baseOperations
+		});
+		return {
+			ok: true,
+			instant: {
+				operations: getOperationsWithQuotaUpdate({
+					operations: baseOperations,
+					state,
+					creditAccount: props.creditAccount,
+					sdk: this.sdk,
+					options
+				}),
+				preview: { min: state.state },
+				calls: []
+			},
+			instantError: void 0,
+			delayedBranch: void 0,
+			delayedError: void 0
+		};
+	}
+	async #finishWithdrawCollateralIntentOnchain({ options, slippage = 0, ...props }) {
+		const quoter = createRouterSwapQuoter({
+			sdk: this.sdk,
+			creditAccount: props.creditAccount,
+			slippage
+		});
+		const baseOperations = await buildResumeWithdrawOperations({
+			...props,
+			options
+		}, quoter);
+		const state = simulateState({
+			...props,
+			operations: baseOperations
+		});
+		const operations = getOperationsWithQuotaUpdate({
+			operations: baseOperations,
+			state,
+			creditAccount: props.creditAccount,
+			sdk: this.sdk,
+			options
+		});
+		const calls = await assembleOperationCalls({
+			...props,
+			operations
+		});
+		return {
+			ok: true,
+			instant: {
+				operations,
+				preview: { min: state.state },
+				calls
+			},
+			instantError: void 0,
+			delayedBranch: void 0,
+			delayedError: void 0
+		};
+	}
+	/**
+	* Resume decrease leverage: claim → (wrapRwa | swap)? → decreaseDebt +
+	* trailing changeQuota. Offchain prices swaps by oracle, onchain — router
+	* swap paths. Router miss soft-fails to the oracle quote (legacy parity).
+	*/
+	async #finishDecreaseLeverageIntent({ options, ...props }) {
+		switch (options.kind) {
+			case "offchain": return this.#finishDecreaseLeverageIntentOffchain({
+				...props,
+				options
+			});
+			default: try {
+				return await this.#finishDecreaseLeverageIntentOnchain({
+					...props,
+					options
+				});
+			} catch {
+				return this.#finishDecreaseLeverageIntentOffchain({
+					...props,
+					options
+				});
+			}
+		}
+	}
+	async #finishDecreaseLeverageIntentOffchain({ options, ...props }) {
+		const quoter = createOracleSwapQuoter({
+			sdk: this.sdk,
+			creditAccount: props.creditAccount
+		});
+		const baseOperations = await buildResumeDecreaseLeverageOperations({
+			...props,
+			options
+		}, quoter);
+		const state = simulateState({
+			...props,
+			operations: baseOperations
+		});
+		return {
+			ok: true,
+			instant: {
+				operations: getOperationsWithQuotaUpdate({
+					operations: baseOperations,
+					state,
+					creditAccount: props.creditAccount,
+					sdk: this.sdk,
+					options
+				}),
+				preview: { min: state.state },
+				calls: []
+			},
+			instantError: void 0,
+			delayedBranch: void 0,
+			delayedError: void 0
+		};
+	}
+	async #finishDecreaseLeverageIntentOnchain({ options, slippage = 0, ...props }) {
+		const quoter = createRouterSwapQuoter({
+			sdk: this.sdk,
+			creditAccount: props.creditAccount,
+			slippage
+		});
+		const baseOperations = await buildResumeDecreaseLeverageOperations({
+			...props,
+			options
+		}, quoter);
+		const state = simulateState({
+			...props,
+			operations: baseOperations
+		});
+		const operations = getOperationsWithQuotaUpdate({
+			operations: baseOperations,
+			state,
+			creditAccount: props.creditAccount,
+			sdk: this.sdk,
+			options
+		});
+		const calls = await assembleOperationCalls({
+			...props,
+			operations
+		});
+		return {
+			ok: true,
+			instant: {
+				operations,
+				preview: { min: state.state },
+				calls
+			},
+			instantError: void 0,
+			delayedBranch: void 0,
+			delayedError: void 0
+		};
+	}
+};
+//#endregion
+export { CreditAccountOperationsService };

package/dist/esm/sdk/accounts/intents/intents/index.js

@@ -0,0 +1,8 @@
+import { buildResumeAddCollateralOperations } from "./resume/add-collateral/add-collateral.js";
+import { buildResumeCloseOperations } from "./resume/close/close.js";
+import { buildResumeDecreaseLeverageOperations } from "./resume/decrease-leverage/decrease-leverage.js";
+import { buildResumeDepositOperations } from "./resume/deposit/deposit.js";
+import { buildResumeIncreaseLeverageOperations } from "./resume/increase-leverage/increase-leverage.js";
+import { buildResumeWithdrawOperations } from "./resume/withdraw/withdraw.js";
+import "./resume/index.js";
+export { buildResumeAddCollateralOperations, buildResumeCloseOperations, buildResumeDecreaseLeverageOperations, buildResumeDepositOperations, buildResumeIncreaseLeverageOperations, buildResumeWithdrawOperations };

package/dist/esm/sdk/accounts/intents/intents/resume/add-collateral/add-collateral.fixtures.js

@@ -0,0 +1,107 @@
+import { ANY, RESUME_FIXTURE_PHANTOM, RWA_ASSET, UND, buildClaimResumeProps, buildOffchainOptions, buildOnchainOptions, buildResumeSdk } from "../../../testing/resume.js";
+//#region src/sdk/accounts/intents/intents/resume/add-collateral/add-collateral.fixtures.ts
+const ADD_UND = 100000000000n;
+const ANY_CLAIMED = 2000000000000000000000n;
+const RWA_CLAIMED = 100000000000n;
+const QUOTA_INCREASE = 92000000000n;
+/** Post-claim metrics after add und-worth collateral (fixed debt). */
+const ADD_T1 = 5100000000000n;
+const ADD_D1 = 4000000000000n;
+/**
+* Flow 1.2 — C=und, T=any (swap then quota).
+* Resume: changeQuota(ANY) only.
+*/
+const case_1_2_und_any = {
+	claimedToken: ANY,
+	claimedAmount: ANY_CLAIMED,
+	postClaimTotalValue: ADD_T1,
+	postClaimDebt: ADD_D1,
+	resumeOps: [{
+		type: "claimDelayedWithdrawal",
+		token: ANY,
+		withdrawalPhantomToken: RESUME_FIXTURE_PHANTOM,
+		withdrawalTokenSpent: ANY_CLAIMED,
+		outputs: [{
+			token: ANY,
+			amount: ANY_CLAIMED,
+			isDelayed: false
+		}],
+		calls: []
+	}, {
+		type: "changeQuota",
+		quotaIncrease: [{
+			token: ANY,
+			balance: QUOTA_INCREASE
+		}],
+		quotaDecrease: [],
+		desiredQuota: {}
+	}],
+	expectedQuotaBalance: QUOTA_INCREASE
+};
+/**
+* Flow 1.7 — C=any, T=asset (swap then quota).
+* Resume: changeQuota(RWA) only.
+*/
+const case_1_7_any_rwa = {
+	claimedToken: RWA_ASSET,
+	claimedAmount: RWA_CLAIMED,
+	postClaimTotalValue: ADD_T1,
+	postClaimDebt: ADD_D1,
+	resumeOps: [{
+		type: "claimDelayedWithdrawal",
+		token: RWA_ASSET,
+		withdrawalPhantomToken: RESUME_FIXTURE_PHANTOM,
+		withdrawalTokenSpent: RWA_CLAIMED,
+		outputs: [{
+			token: RWA_ASSET,
+			amount: RWA_CLAIMED,
+			isDelayed: false
+		}],
+		calls: []
+	}, {
+		type: "changeQuota",
+		quotaIncrease: [{
+			token: RWA_ASSET,
+			balance: QUOTA_INCREASE
+		}],
+		quotaDecrease: [],
+		desiredQuota: {}
+	}],
+	expectedQuotaBalance: QUOTA_INCREASE
+};
+/** Claimed und — no active quota-buy path. */
+const case_claimed_und = {
+	claimedToken: UND,
+	claimedAmount: ADD_UND,
+	postClaimTotalValue: 5000000000000n,
+	postClaimDebt: 4000000000000n,
+	baseAssets: [{
+		token: ANY,
+		balance: 98000000000000000000000n,
+		quota: 0n,
+		mask: 0n,
+		success: true
+	}],
+	resumeOps: [{
+		type: "claimDelayedWithdrawal",
+		token: UND,
+		withdrawalPhantomToken: RESUME_FIXTURE_PHANTOM,
+		withdrawalTokenSpent: ADD_UND,
+		outputs: [{
+			token: UND,
+			amount: ADD_UND,
+			isDelayed: false
+		}],
+		calls: []
+	}]
+};
+function buildResumeAddCollateralProps(args) {
+	return buildClaimResumeProps({
+		intent: { type: "ADD_COLLATERAL" },
+		case: args.case,
+		sdk: args.sdk,
+		options: args.options
+	});
+}
+//#endregion
+export { ADD_UND, ANY, ANY_CLAIMED, QUOTA_INCREASE, RWA_ASSET, RWA_CLAIMED, UND, buildOffchainOptions, buildOnchainOptions, buildResumeAddCollateralProps, buildResumeSdk, case_1_2_und_any, case_1_7_any_rwa, case_claimed_und };

package/dist/esm/sdk/accounts/intents/intents/resume/add-collateral/add-collateral.js

@@ -0,0 +1,14 @@
+import { buildClaimDelayedWithdrawalOperation } from "../../../operations/claim-delayed/index.js";
+import "../../../operations/index.js";
+//#region src/sdk/accounts/intents/intents/resume/add-collateral/add-collateral.ts
+/**
+* Resume add-collateral: claim only
+*/
+function buildResumeAddCollateralOperations(creditAccount, options, sdk) {
+	return [buildClaimDelayedWithdrawalOperation({
+		creditAccount,
+		sdk
+	}, options)];
+}
+//#endregion
+export { buildResumeAddCollateralOperations };

package/dist/esm/sdk/accounts/intents/intents/resume/close/close.fixtures.js

@@ -0,0 +1,94 @@
+import { toBN } from "../../../../../utils/formatter.js";
+import "../../../../../index.js";
+import { CREDIT_ACCOUNT, CREDIT_FACADE, CREDIT_MANAGER, RESUME_FIXTURE_PHANTOM, RWA_ASSET, UND, buildOffchainOptions, buildOnchainOptions, buildResumeSdk, claimedValueInUnd } from "../../../testing/resume.js";
+//#region src/sdk/accounts/intents/intents/resume/close/close.fixtures.ts
+/**
+* Resume close fixtures, ported from intent-calculator
+* `closeAccount.flowFixtures.ts` (resume cases only).
+*
+* The oracle quoter repays debt from NON-underlying value
+* (`amount = Σ convert(non-underlying) − debt`), so the base balance is held
+* in TOK worth `CLOSE_T0` (minus the claimed token's value when the claim
+* adds convertible value) and the derived amount matches `CLOSE_EQUITY`.
+*/
+const CLOSE_T0 = 5000000000000n;
+const CLOSE_D0 = 4000000000000n;
+const CLOSE_EQUITY = 1000000000000n;
+const CLAIMED = 1000000n;
+const A0_TOK = toBN("100000", 18);
+/** TOK worth CLOSE_T0 (TOK $1 vs UND $2, 18→8 decimals). */
+const BASE_TOK = toBN("100000", 18);
+/** Wallet recipient of the close withdraw (legacy `mockAccount`). */
+const CLOSE_TO = "0x1234567890123456789012345678901234567890";
+const rwaUnderlyingMeta = { asset: RWA_ASSET };
+/** Resume: claim first, then same close op as full flow. */
+const closeResumeOps = [{
+	type: "claimDelayedWithdrawal",
+	token: UND,
+	withdrawalPhantomToken: RESUME_FIXTURE_PHANTOM,
+	withdrawalTokenSpent: 0n,
+	outputs: [{
+		token: UND,
+		amount: 0n,
+		isDelayed: false
+	}],
+	calls: []
+}, {
+	type: "closeCreditAccount",
+	amount: CLOSE_EQUITY,
+	minAmount: CLOSE_EQUITY,
+	underlyingBalance: CLOSE_EQUITY,
+	calls: []
+}];
+const closePreviewState = {
+	kind: "close",
+	amount: CLOSE_EQUITY,
+	minAmount: CLOSE_EQUITY,
+	underlyingBalance: CLOSE_EQUITY
+};
+function buildCloseSdk(args) {
+	return buildResumeSdk({ claimedToken: args.claimedToken }, {
+		closePath: args.closePath,
+		rwaAssets: args.rwaAssets
+	});
+}
+/** Pre-claim CA for resume: phantom balance; claim op credits claimed token then close. */
+function buildCloseResumeProps(args) {
+	const claimedToken = args.claimedToken ?? "0x3333333333333333333333333333333333333333";
+	const claimedAmount = args.claimedAmount ?? 0n;
+	const creditAccount = {
+		creditAccount: CREDIT_ACCOUNT,
+		creditManager: CREDIT_MANAGER,
+		creditFacade: CREDIT_FACADE,
+		underlying: UND,
+		enabledTokensMask: 0n,
+		totalDebtUSD: 0n,
+		accountDebt: CLOSE_D0,
+		tokens: args.tokens ?? [{
+			token: "0xcccccccccccccccccccccccccccccccccccccccc",
+			balance: claimedAmount,
+			quota: 0n,
+			mask: 0n,
+			success: true
+		}, {
+			token: "0x1111111111111111111111111111111111111111",
+			balance: claimedToken === "0x3333333333333333333333333333333333333333" ? BASE_TOK : BASE_TOK - claimedValueInUnd(claimedAmount, claimedToken) * 20000000000n,
+			quota: 0n,
+			mask: 0n,
+			success: true
+		}]
+	};
+	return {
+		intent: {
+			type: "CLOSE_ACCOUNT",
+			to: CLOSE_TO
+		},
+		creditAccount,
+		sdk: args.sdk,
+		quotaReserve: void 0,
+		options: args.options,
+		slippage: args.slippage ?? 50
+	};
+}
+//#endregion
+export { A0_TOK, CLAIMED, CLOSE_D0, CLOSE_EQUITY, CLOSE_T0, CLOSE_TO, CREDIT_ACCOUNT, buildCloseResumeProps, buildCloseSdk, buildOffchainOptions, buildOnchainOptions, closePreviewState, closeResumeOps, rwaUnderlyingMeta };

package/dist/esm/sdk/accounts/intents/intents/resume/close/close.js

@@ -0,0 +1,50 @@
+import { toRouterCaSlice } from "../../../utils/common.js";
+import { convertAmount } from "../../../utils/convert-amount.js";
+import { simulateOperationAssets } from "../../../utils/simulate-assets.js";
+import "../../../utils/index.js";
+import { buildClaimDelayedWithdrawalOperation } from "../../../operations/claim-delayed/index.js";
+import { buildCloseCreditAccountOperation } from "../../../operations/close-credit-account/index.js";
+import "../../../operations/index.js";
+//#region src/sdk/accounts/intents/intents/resume/close/close.ts
+/**
+* Resume close — linear op chain: claim, then close against the quoted
+* post-claim balances. Quota zeroing and debt/withdraw live inside
+* assembleCloseCreditAccountCalls — no separate changeQuota / wrap ops.
+*/
+async function buildResumeCloseOperations(props, quoter) {
+	const { options, creditAccount, sdk, intent } = props;
+	const operations = [buildClaimDelayedWithdrawalOperation({
+		creditAccount,
+		sdk
+	}, options)];
+	const convert = convertAmount(sdk, creditAccount.creditManager);
+	const { assets: assetsAfterClaim, debt } = simulateOperationAssets({
+		initialAssets: creditAccount.tokens,
+		operations,
+		underlyingToken: creditAccount.underlying,
+		debt: creditAccount.accountDebt,
+		convert
+	});
+	const quote = await quoter({
+		assets: assetsAfterClaim,
+		debt
+	});
+	if (options.kind === "onchain") operations.push(await buildCloseCreditAccountOperation({
+		quote,
+		sdk
+	}, {
+		...options,
+		to: intent.to,
+		creditAccount: toRouterCaSlice(creditAccount, assetsAfterClaim)
+	}));
+	else operations.push(await buildCloseCreditAccountOperation({
+		quote,
+		sdk
+	}, options));
+	return {
+		operations,
+		quote
+	};
+}
+//#endregion
+export { buildResumeCloseOperations };