@gearbox-protocol/sdk 16.0.0-next.41 → 16.0.0-next.42

package/dist/cjs/model/errors.js

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/cjs/model/index.js

@@ -6,6 +6,7 @@ const require_model_charts_schema = require("./charts.schema.js");
 require("./curators.js");
 const require_model_curators_schema = require("./curators.schema.js");
 require("./delayed-intents.js");
+require("./errors.js");
 const require_model_filters = require("./filters.js");
 const require_model_filters_schema = require("./filters.schema.js");
 const require_model_liquidations = require("./liquidations.js");

package/dist/cjs/onchain/accounts/intents/open-strategy.js

@@ -11,7 +11,7 @@ require("./utils/index.js");
 const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 /**
 * Builds the state opening a leveraged position out of wallet collateral would
-* land in.
+* reach.
 *
 * Debt follows from the target leverage against the supplied margin
 * (`debt = margin * (L - 1)`, `totalValue = margin * L`); the collateral and the

package/dist/cjs/sdk/execute/ExecuteApi.js

@@ -12,7 +12,7 @@ var ExecuteApi = class {
 	* {@inheritDoc IOpportunitiesExecute.buildTx}
 	**/
 	async buildTx(request) {
-		if (!request.sim.ok) throw new Error(`cannot build a transaction from a failed ${request.kind} preparation`);
+		if (!request.sim.success) throw new Error(`cannot build a transaction from a failed ${request.kind} preparation`);
 		const sdk = this.#chainOf(request.chainId);
 		switch (request.kind) {
 			case "pool": return poolTx(sdk, request);
@@ -23,7 +23,7 @@ var ExecuteApi = class {
 };
 function poolTx(sdk, request) {
 	const { pool, wallet, sim } = request;
-	const { tokenIn, tokenOut } = sim.state;
+	const { tokenIn, tokenOut } = sim.data.state;
 	if (request.op === "deposit") {
 		const meta = sdk.pools.getDepositMetadata(pool, tokenIn.token.address, tokenOut.token.address);
 		const result = sdk.pools.addLiquidity({
@@ -50,7 +50,7 @@ function poolTx(sdk, request) {
 }
 async function openTx(sdk, request) {
 	const { creditManager, wallet, collateral, ethAmount, sim } = request;
-	const { state } = sim;
+	const { state } = sim.data;
 	return sdk.accounts.openCA({
 		creditManager,
 		to: wallet,
@@ -83,7 +83,7 @@ async function openRwaOptions(sdk, request) {
 async function accountTx(sdk, request) {
 	const account = await sdk.accounts.getCreditAccountData(request.creditAccount);
 	if (!account) throw new Error(`credit account not found: ${request.creditAccount}`);
-	return sdk.accounts.executeCaUpdate(account, request.sim.calls, { ethAmount: nativeValue(request.sim.operations) });
+	return sdk.accounts.executeCaUpdate(account, request.sim.data.calls, { ethAmount: nativeValue(request.sim.data.operations) });
 }
 /**
 * The coin the preparation asked the wallet for, which the facade wraps out of

package/dist/cjs/sdk/index.js

@@ -13,6 +13,7 @@ const require_sdk_liquidations_LiquidationsNamespace = require("./liquidations/L
 require("./liquidations/index.js");
 const require_sdk_execute_ExecuteApi = require("./execute/ExecuteApi.js");
 require("./execute/index.js");
+const require_sdk_prepare_errors = require("./prepare/errors.js");
 const require_sdk_prepare_PrepareApi = require("./prepare/PrepareApi.js");
 require("./prepare/index.js");
 const require_sdk_utils_filterResponse = require("./utils/filterResponse.js");
@@ -43,9 +44,13 @@ exports.PreviewNamespace = require_sdk_preview_PreviewNamespace.PreviewNamespace
 exports.SourceChainMismatchError = require_sdk_errors_SourceChainMismatchError.SourceChainMismatchError;
 exports.SourceUnavailableError = require_sdk_errors_SourceUnavailableError.SourceUnavailableError;
 exports.assertSameChains = require_sdk_errors_assertSameChains.assertSameChains;
+exports.creditAccountNotFound = require_sdk_prepare_errors.creditAccountNotFound;
 exports.everyChainFailed = require_sdk_errors_everyChainFailed.everyChainFailed;
 exports.filterResponse = require_sdk_utils_filterResponse.filterResponse;
 exports.mergeChainList = require_sdk_utils_mergeChains.mergeChainList;
 exports.mergeChainOne = require_sdk_utils_mergeChains.mergeChainOne;
+exports.noStrategyTargetCollateral = require_sdk_prepare_errors.noStrategyTargetCollateral;
 exports.raise = require_onchain_validation_refusal.raise;
 exports.refuse = require_onchain_validation_refusal.refuse;
+exports.toPrepareError = require_sdk_prepare_errors.toPrepareError;
+exports.unexpectedFailure = require_sdk_prepare_errors.unexpectedFailure;

package/dist/cjs/sdk/prepare/PrepareApi.js

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_utils_hex = require("../../onchain/utils/hex.js");
 const require_onchain_base_MultichainConstruct = require("../../onchain/base/MultichainConstruct.js");
-const require_onchain_validation_refusal = require("../../onchain/validation/refusal.js");
 const require_onchain_validation_token = require("../../onchain/validation/token.js");
 const require_onchain_accounts_intents_utils_credit_account_slice = require("../../onchain/accounts/intents/utils/credit-account-slice.js");
 const require_onchain_accounts_intents_index = require("../../onchain/accounts/intents/index.js");
 require("../../onchain/index.js");
+const require_sdk_prepare_errors = require("./errors.js");
 const require_sdk_prepare_withdrawable_collaterals = require("./withdrawable-collaterals.js");
 //#region src/sdk/prepare/PrepareApi.ts
 /**
@@ -18,8 +18,13 @@ const require_sdk_prepare_withdrawable_collaterals = require("./withdrawable-col
 *
 * A prepared operation names one chain, so it reads through
 * {@link MultichainConstruct.queryChain}: there is no second source to fall back
-* to, hence a chain the SDK does not cover, or one that fails the read, throws
-* rather than answering with empty metadata.
+* to, hence a chain the SDK does not cover, or one that fails the read, is a
+* failure of the whole request rather than a thinner answer.
+*
+* No method here throws. Every way a preparation can fail — the market's own
+* refusals, the two the namespace decides itself, and anything the chain or the
+* engine raises — comes back described in the envelope, see {@link PrepareError}.
+* A caller writes one branch, not a branch and a `try`.
 **/
 var PrepareApi = class extends require_onchain_base_MultichainConstruct.MultichainConstruct {
 	#ensureFresh;
@@ -32,29 +37,77 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 		return super.queryChain(props);
 	}
 	/**
+	* Runs a one-chain request whose answer is an envelope, describing whatever
+	* the chain, the read or the engine throws on the way rather than letting it
+	* escape.
+	*
+	* So every method below answers instead of rejecting, and a caller has one
+	* thing to branch on. "This cannot be done" and "we could not find out" are
+	* still told apart, by `error.code`: only the second is
+	* `unexpectedFailure`, and only it marks the chain failed in `meta`.
+	**/
+	async #answer(chainId, run) {
+		try {
+			return await this.queryChain({
+				network: chainId,
+				run
+			});
+		} catch (e) {
+			return {
+				data: {
+					success: false,
+					error: require_sdk_prepare_errors.unexpectedFailure(e)
+				},
+				meta: { chains: [failedChain(chainId, e)] }
+			};
+		}
+	}
+	/**
 	* {@inheritDoc IOpportunitiesPrepare.finalize}
 	**/
 	async finalize(position, params) {
-		return this.queryChain({
-			network: position.chainId,
-			run: async (sdk) => {
-				const intent = resumable(params.intent ?? params.claimable.intent);
-				if (!intent) return require_onchain_validation_refusal.refuse("noRecordedIntent", void 0);
-				return service(sdk).finishIntent({
-					intent,
-					claimable: toClaimableWithdrawal(params.claimable),
-					creditAccount: await slice(sdk, position.creditAccount),
-					sdk,
-					slippage: params.slippage,
-					quotaReserve: params.quotaReserve
-				});
-			}
+		return this.#answer(position.chainId, async (sdk) => {
+			const intent = resumable(params.intent ?? params.claimable.intent);
+			if (!intent) return {
+				success: false,
+				error: require_sdk_prepare_errors.toPrepareError({
+					reason: "noRecordedIntent",
+					detail: void 0
+				})
+			};
+			const creditAccount = await slice(sdk, position.creditAccount);
+			if (!creditAccount) return {
+				success: false,
+				error: require_sdk_prepare_errors.creditAccountNotFound(position.creditAccount)
+			};
+			return planned(await service(sdk).finishIntent({
+				intent,
+				claimable: toClaimableWithdrawal(params.claimable),
+				creditAccount,
+				sdk,
+				slippage: params.slippage,
+				quotaReserve: params.quotaReserve
+			}));
 		});
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.deposit}
 	**/
 	deposit(pool, params) {
+		try {
+			return this.#depositPlan(pool, params);
+		} catch (e) {
+			return {
+				success: false,
+				error: require_sdk_prepare_errors.unexpectedFailure(e)
+			};
+		}
+	}
+	/**
+	* The arithmetic behind {@link deposit}, which throws where the SDK holds
+	* nothing for the pool or the chain it was handed.
+	**/
+	#depositPlan(pool, params) {
 		const chain = this.sdk.chain(pool.chainId);
 		const { marketRegister, pools } = chain;
 		const tokenIn = params.tokenIn ?? marketRegister.findByPool(pool.pool).pool.underlying;
@@ -77,16 +130,31 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 		});
 		if (!call) return unroutable(chain, tokenIn, tokenOut);
 		return {
-			ok: true,
-			operations: [],
-			state,
-			calls: call.calls
+			success: true,
+			data: {
+				operations: [],
+				state,
+				calls: call.calls
+			}
 		};
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.withdraw}
 	**/
 	withdraw(pool, params) {
+		try {
+			return this.#withdrawPlan(pool, params);
+		} catch (e) {
+			return {
+				success: false,
+				error: require_sdk_prepare_errors.unexpectedFailure(e)
+			};
+		}
+	}
+	/**
+	* {@inheritDoc PrepareApi.depositPlan}
+	**/
+	#withdrawPlan(pool, params) {
 		const chain = this.sdk.chain(pool.chainId);
 		const { pools } = chain;
 		const tokenIn = params.tokenIn ?? pool.pool;
@@ -107,16 +175,31 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 			mode: "withdraw"
 		});
 		return {
-			ok: true,
-			operations: [],
-			state,
-			calls
+			success: true,
+			data: {
+				operations: [],
+				state,
+				calls
+			}
 		};
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.redeem}
 	**/
 	redeem(pool, params) {
+		try {
+			return this.#redeemPlan(pool, params);
+		} catch (e) {
+			return {
+				success: false,
+				error: require_sdk_prepare_errors.unexpectedFailure(e)
+			};
+		}
+	}
+	/**
+	* {@inheritDoc PrepareApi.depositPlan}
+	**/
+	#redeemPlan(pool, params) {
 		const chain = this.sdk.chain(pool.chainId);
 		const { pools } = chain;
 		const tokenIn = params.tokenIn ?? pool.pool;
@@ -137,32 +220,34 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 			mode: "redeem"
 		});
 		return {
-			ok: true,
-			operations: [],
-			state,
-			calls
+			success: true,
+			data: {
+				operations: [],
+				state,
+				calls
+			}
 		};
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.openNewStrategy}
 	**/
 	async openNewStrategy(strategy, params) {
-		return this.queryChain({
-			network: strategy.chainId,
-			run: (sdk) => {
-				const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategyTargetCollateral;
-				if (!targetToken) throw new Error(`credit manager ${strategy.creditManager} has no strategy target collateral`);
-				return service(sdk).openStrategyIntent({
-					sdk,
-					creditManager: strategy.creditManager,
-					collateral: params.collateral,
-					targetToken,
-					leverage: params.leverage,
-					leftoverBalances: params.leftoverBalances,
-					slippage: params.slippage,
-					quotaReserve: params.quotaReserve
-				});
-			}
+		return this.#answer(strategy.chainId, async (sdk) => {
+			const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategyTargetCollateral;
+			if (!targetToken) return {
+				success: false,
+				error: require_sdk_prepare_errors.noStrategyTargetCollateral(strategy.creditManager)
+			};
+			return opened(await service(sdk).openStrategyIntent({
+				sdk,
+				creditManager: strategy.creditManager,
+				collateral: params.collateral,
+				targetToken,
+				leverage: params.leverage,
+				leftoverBalances: params.leftoverBalances,
+				slippage: params.slippage,
+				quotaReserve: params.quotaReserve
+			}));
 		});
 	}
 	/**
@@ -194,12 +279,19 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 	* {@inheritDoc IOpportunitiesPrepare.maxWithdraw}
 	**/
 	async maxWithdraw(position) {
-		return this.queryChain({
-			network: position.chainId,
-			run: async (sdk) => service(sdk).maxWithdraw({
-				creditAccount: await slice(sdk, position.creditAccount),
-				sdk
-			})
+		return this.#answer(position.chainId, async (sdk) => {
+			const creditAccount = await slice(sdk, position.creditAccount);
+			if (!creditAccount) return {
+				success: false,
+				error: require_sdk_prepare_errors.creditAccountNotFound(position.creditAccount)
+			};
+			return {
+				success: true,
+				data: await service(sdk).maxWithdraw({
+					creditAccount,
+					sdk
+				})
+			};
 		});
 	}
 	/**
@@ -217,12 +309,19 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 	* {@inheritDoc IOpportunitiesPrepare.maxRepay}
 	**/
 	async maxRepay(position) {
-		return this.queryChain({
-			network: position.chainId,
-			run: async (sdk) => service(sdk).maxRepay({
-				creditAccount: await slice(sdk, position.creditAccount),
-				sdk
-			})
+		return this.#answer(position.chainId, async (sdk) => {
+			const creditAccount = await slice(sdk, position.creditAccount);
+			if (!creditAccount) return {
+				success: false,
+				error: require_sdk_prepare_errors.creditAccountNotFound(position.creditAccount)
+			};
+			return {
+				success: true,
+				data: await service(sdk).maxRepay({
+					creditAccount,
+					sdk
+				})
+			};
 		});
 	}
 	/**
@@ -279,14 +378,21 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 	* {@inheritDoc IOpportunitiesPrepare.maxWithdrawCollateral}
 	**/
 	async maxWithdrawCollateral(position, token, targetHF) {
-		return this.queryChain({
-			network: position.chainId,
-			run: async (sdk) => service(sdk).maxWithdrawCollateral({
-				creditAccount: await slice(sdk, position.creditAccount),
-				sdk,
-				token,
-				targetHF
-			})
+		return this.#answer(position.chainId, async (sdk) => {
+			const creditAccount = await slice(sdk, position.creditAccount);
+			if (!creditAccount) return {
+				success: false,
+				error: require_sdk_prepare_errors.creditAccountNotFound(position.creditAccount)
+			};
+			return {
+				success: true,
+				data: await service(sdk).maxWithdrawCollateral({
+					creditAccount,
+					sdk,
+					token,
+					targetHF
+				})
+			};
 		});
 	}
 	/**
@@ -294,42 +400,60 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 	* two routes to offer: one account read, one intent, both routes quoted.
 	**/
 	async #startRoutes(position, options, intent) {
-		return this.queryChain({
-			network: position.chainId,
-			run: async (sdk) => service(sdk).intentRoutes({
-				intent,
-				creditAccount: await slice(sdk, position.creditAccount),
-				sdk,
-				slippage: options.slippage,
-				quotaReserve: options.quotaReserve
-			})
-		});
+		try {
+			return await this.queryChain({
+				network: position.chainId,
+				run: async (sdk) => {
+					const creditAccount = await slice(sdk, position.creditAccount);
+					if (!creditAccount) return neitherRoute(require_sdk_prepare_errors.creditAccountNotFound(position.creditAccount));
+					return routed(await service(sdk).intentRoutes({
+						intent,
+						creditAccount,
+						sdk,
+						slippage: options.slippage,
+						quotaReserve: options.quotaReserve
+					}));
+				}
+			});
+		} catch (e) {
+			return {
+				data: neitherRoute(require_sdk_prepare_errors.unexpectedFailure(e)),
+				meta: { chains: [failedChain(position.chainId, e)] }
+			};
+		}
 	}
 	/**
 	* Shared path of the five flows that act on an existing account: read the
 	* account, then run the intent through the engine.
 	**/
 	async #startIntent(position, options, intent) {
-		return this.queryChain({
-			network: position.chainId,
-			run: async (sdk) => {
-				const creditAccount = await slice(sdk, position.creditAccount);
-				return service(sdk).startIntent({
-					intent,
-					creditAccount,
-					sdk,
-					slippage: options.slippage,
-					quotaReserve: options.quotaReserve
-				});
-			}
+		return this.#answer(position.chainId, async (sdk) => {
+			const creditAccount = await slice(sdk, position.creditAccount);
+			if (!creditAccount) return {
+				success: false,
+				error: require_sdk_prepare_errors.creditAccountNotFound(position.creditAccount)
+			};
+			return planned(await service(sdk).startIntent({
+				intent,
+				creditAccount,
+				sdk,
+				slippage: options.slippage,
+				quotaReserve: options.quotaReserve
+			}));
 		});
 	}
 };
 function service(sdk) {
 	return new require_onchain_accounts_intents_index.CreditAccountOperationsService(sdk);
 }
-function slice(sdk, creditAccount) {
-	return require_onchain_accounts_intents_utils_credit_account_slice.fetchCreditAccountSlice(sdk, creditAccount);
+/**
+* The account the request names, or nothing where the markets this SDK is
+* connected to hold no such account — closed since it was listed, or named on
+* the wrong chain. Read rather than thrown, so the caller gets a code for it.
+**/
+async function slice(sdk, creditAccount) {
+	const data = await sdk.accounts.getCreditAccountData(creditAccount);
+	return data && require_onchain_accounts_intents_utils_credit_account_slice.toCreditAccountSlice(data);
 }
 /**
 * The operation a claim resumes, or `undefined` when there is none to resume:
@@ -362,6 +486,36 @@ function toClaimableWithdrawal(claimable) {
 	};
 }
 /**
+* A flow with two routes, refused before either could be quoted: the error is
+* the same one any other flow would report, with nothing to say about the
+* routes because neither was reached.
+**/
+function neitherRoute(error) {
+	return {
+		success: false,
+		error: {
+			...error,
+			refused: {
+				instant: void 0,
+				delayed: void 0
+			}
+		}
+	};
+}
+/**
+* The chain entry for a request that was answered with
+* {@link UnexpectedFailureError}: the read did not happen, so the metadata says
+* so rather than reporting a block it never got.
+**/
+function failedChain(chainId, error) {
+	return {
+		chainId,
+		status: "error",
+		source: "onchain",
+		error
+	};
+}
+/**
 * A pool route the market does not offer, as the refusal a caller reads.
 *
 * `to` is absent where {@link lpRoute} found no output to name at all, which
@@ -369,10 +523,89 @@ function toClaimableWithdrawal(claimable) {
 * ours implements it.
 **/
 function unroutable(sdk, from, to) {
-	return require_onchain_validation_refusal.refuse("unsupportedTokenPair", {
-		from: require_onchain_validation_token.toToken(sdk, from),
-		to: to === void 0 ? void 0 : require_onchain_validation_token.toToken(sdk, to)
-	});
+	return {
+		success: false,
+		error: require_sdk_prepare_errors.toPrepareError({
+			reason: "unsupportedTokenPair",
+			detail: {
+				from: require_onchain_validation_token.toToken(sdk, from),
+				to: to === void 0 ? void 0 : require_onchain_validation_token.toToken(sdk, to)
+			}
+		})
+	};
+}
+/**
+* The engine's answer, as the envelope the namespace speaks in: what the
+* operation comes to under `data`, or the refusal as an error carrying its own
+* numbers, see {@link toPrepareError}.
+*
+* The engine keeps its `ok` union — it is the shape the planners, the guards
+* and their tests are written against — and the boundary is the one place the
+* two vocabularies meet.
+**/
+function planned(result) {
+	if (!result.ok) return {
+		success: false,
+		error: require_sdk_prepare_errors.toPrepareError(result)
+	};
+	const { operations, state, calls } = result;
+	return {
+		success: true,
+		data: {
+			operations,
+			state,
+			calls
+		}
+	};
+}
+/**
+* {@inheritDoc planned}
+**/
+function opened(result) {
+	return result.ok ? {
+		success: true,
+		data: { state: result.state }
+	} : {
+		success: false,
+		error: require_sdk_prepare_errors.toPrepareError(result)
+	};
+}
+/**
+* {@inheritDoc planned}
+*
+* Both routes are payload, refusal and all: `refused` says why a missing one is
+* missing, and it stays on the error when neither route answered, since that is
+* the same question asked of a request that has no viable half at all.
+**/
+function routed(result) {
+	if (!result.ok) {
+		const { refused, ...issue } = result;
+		return {
+			success: false,
+			error: {
+				...require_sdk_prepare_errors.toPrepareError(issue),
+				refused
+			}
+		};
+	}
+	const { instant, delayed, refused } = result;
+	return {
+		success: true,
+		data: {
+			instant: instant && {
+				operations: instant.operations,
+				state: instant.state,
+				calls: instant.calls
+			},
+			delayed: delayed && {
+				operations: delayed.operations,
+				state: delayed.state,
+				calls: delayed.calls,
+				delayed: delayed.delayed
+			},
+			refused
+		}
+	};
 }
 /**
 * Picks the route the operation takes out of `tokenIn`, as a value rather than