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

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

@@ -1,11 +1,13 @@
 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_model_result = require("../../model/result.js");
+require("../../model/index.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
 /**
@@ -16,10 +18,18 @@ const require_sdk_prepare_withdrawable_collaterals = require("./withdrawable-col
 * protocol knowledge stays in `CreditAccountOperationsService` and
 * `PoolService`.
 *
-* 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.
+* A prepared operation names one chain and reads it directly: there is no
+* second source to fall back to, so 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 refusable async method here throws. Every way such a preparation can
+* fail — the market's own refusals, the ones the namespace decides itself, and
+* anything the chain or the engine raises — comes back in the failure half of
+* its `SDKReturn`, under the codes that method's signature names. A caller
+* writes one branch, not a branch and a `try`. The synchronous LP methods and
+* the bare `max*` reads throw on bugs and lifecycle errors instead, see
+* {@link IOpportunitiesPrepare}.
 **/
 var PrepareApi = class extends require_onchain_base_MultichainConstruct.MultichainConstruct {
 	#ensureFresh;
@@ -27,29 +37,39 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 		super(sdk);
 		this.#ensureFresh = ensureFresh;
 	}
-	async queryChain(props) {
-		await this.#ensureFresh?.([this.sdk.chain(props.network).chainId]);
-		return super.queryChain(props);
+	/**
+	* The chain an async method reads, revalidated first so the state it is
+	* about to weigh is no older than the SDK's freshness bar.
+	**/
+	async #chain(chainId) {
+		await this.#ensureFresh?.([this.sdk.chain(chainId).chainId]);
+		return this.sdk.chain(chainId);
 	}
 	/**
 	* {@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
-				});
-			}
-		});
+		try {
+			const sdk = await this.#chain(position.chainId);
+			const at = stateBlock(sdk);
+			const intent = resumable(params.intent ?? params.claimable.intent);
+			if (!intent) return require_model_result.sdkErr(require_sdk_prepare_errors.toRefusalError({
+				reason: "noRecordedIntent",
+				detail: void 0
+			}));
+			const creditAccount = await slice(sdk, position.creditAccount);
+			if (!creditAccount) return require_model_result.sdkErr(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
+			}), at);
+		} catch (e) {
+			return require_model_result.sdkErr(require_sdk_prepare_errors.unexpectedFailure(e));
+		}
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.deposit}
@@ -76,12 +96,12 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 			meta: pools.getDepositMetadata(pool.pool, tokenIn, tokenOut)
 		});
 		if (!call) return unroutable(chain, tokenIn, tokenOut);
-		return {
-			ok: true,
+		return require_model_result.sdkOk({
 			operations: [],
 			state,
-			calls: call.calls
-		};
+			calls: call.calls,
+			...stateBlock(chain)
+		});
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.withdraw}
@@ -106,12 +126,12 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 			meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
 			mode: "withdraw"
 		});
-		return {
-			ok: true,
+		return require_model_result.sdkOk({
 			operations: [],
 			state,
-			calls
-		};
+			calls,
+			...stateBlock(chain)
+		});
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.redeem}
@@ -136,34 +156,35 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 			meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
 			mode: "redeem"
 		});
-		return {
-			ok: true,
+		return require_model_result.sdkOk({
 			operations: [],
 			state,
-			calls
-		};
+			calls,
+			...stateBlock(chain)
+		});
 	}
 	/**
 	* {@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
-				});
-			}
-		});
+		try {
+			const sdk = await this.#chain(strategy.chainId);
+			const at = stateBlock(sdk);
+			const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategyTargetCollateral;
+			if (!targetToken) return require_model_result.sdkErr(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
+			}), at);
+		} catch (e) {
+			return require_model_result.sdkErr(require_sdk_prepare_errors.unexpectedFailure(e));
+		}
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.depositStrategy}
@@ -194,12 +215,11 @@ 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
-			})
+		const sdk = await this.#chain(position.chainId);
+		const creditAccount = await this.#account(sdk, position);
+		return service(sdk).maxWithdraw({
+			creditAccount,
+			sdk
 		});
 	}
 	/**
@@ -217,12 +237,11 @@ 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
-			})
+		const sdk = await this.#chain(position.chainId);
+		const creditAccount = await this.#account(sdk, position);
+		return service(sdk).maxRepay({
+			creditAccount,
+			sdk
 		});
 	}
 	/**
@@ -279,57 +298,99 @@ 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
-			})
+		const sdk = await this.#chain(position.chainId);
+		const creditAccount = await this.#account(sdk, position);
+		return service(sdk).maxWithdrawCollateral({
+			creditAccount,
+			sdk,
+			token,
+			targetHF
 		});
 	}
 	/**
-	* Shared path of the two flows that sell a position asset, and therefore have
-	* two routes to offer: one account read, one intent, both routes quoted.
+	* The account a bare `max*` read weighs. These reads answer a number, not
+	* an envelope, so an account the markets do not hold is thrown rather than
+	* described, see {@link IOpportunitiesPrepare.maxWithdraw}.
+	**/
+	async #account(sdk, position) {
+		const creditAccount = await slice(sdk, position.creditAccount);
+		if (!creditAccount) throw new Error(require_sdk_prepare_errors.creditAccountNotFound(position.creditAccount).message);
+		return creditAccount;
+	}
+	/**
+	* Shared path of the two flows that sell a position asset, and therefore
+	* have two routes to offer: one account read, one intent, both routes
+	* quoted. Every refusal, the crash wrap included, carries `refused` so a
+	* form can say which routes were ruled out and why.
+	*
+	* @typeParam X - The codes the calling flow can raise beyond the shared
+	* ones, per the engine trace its signature spells out.
 	**/
 	async #startRoutes(position, options, intent) {
-		return this.queryChain({
-			network: position.chainId,
-			run: async (sdk) => service(sdk).intentRoutes({
+		try {
+			const sdk = await this.#chain(position.chainId);
+			const at = stateBlock(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: await slice(sdk, position.creditAccount),
+				creditAccount,
 				sdk,
 				slippage: options.slippage,
 				quotaReserve: options.quotaReserve
-			})
-		});
+			}), at);
+		} catch (e) {
+			return neitherRoute(require_sdk_prepare_errors.unexpectedFailure(e));
+		}
 	}
 	/**
 	* Shared path of the five flows that act on an existing account: read the
-	* account, then run the intent through the engine.
+	* account, then run the intent through the engine. Whatever the chain or
+	* the engine throws on the way is described as `unexpectedFailure` instead
+	* of escaping, so the flow always answers.
+	*
+	* @typeParam X - The codes the calling flow can raise beyond the shared
+	* ones, per the engine trace its signature spells out.
 	**/
 	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
-				});
-			}
-		});
+		try {
+			const sdk = await this.#chain(position.chainId);
+			const at = stateBlock(sdk);
+			const creditAccount = await slice(sdk, position.creditAccount);
+			if (!creditAccount) return require_model_result.sdkErr(require_sdk_prepare_errors.creditAccountNotFound(position.creditAccount));
+			return planned(await service(sdk).startIntent({
+				intent,
+				creditAccount,
+				sdk,
+				slippage: options.slippage,
+				quotaReserve: options.quotaReserve
+			}), at);
+		} catch (e) {
+			return require_model_result.sdkErr(require_sdk_prepare_errors.unexpectedFailure(e));
+		}
 	}
 };
 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);
+/**
+* Reads the block the SDK's loaded state stands at — the same state every
+* preparation below is computed from, so it is the block the result reports.
+**/
+function stateBlock(sdk) {
+	return {
+		blockNumber: Number(sdk.currentBlock),
+		timestamp: Number(sdk.timestamp)
+	};
+}
+/**
+* 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 +423,95 @@ function toClaimableWithdrawal(claimable) {
 	};
 }
 /**
+* The engine's refusal as one flow's failure half.
+*
+* The engine answers with the open union of every reason it can raise
+* anywhere; which of them a given flow actually reaches is the engine trace
+* written into the public signatures. This cast is the one place the open
+* union is narrowed onto them — a code added to or removed from a flow has to
+* move its signature, which `types.test-d.ts` pins.
+**/
+function refusal(issue) {
+	return require_model_result.sdkErr(require_sdk_prepare_errors.toRefusalError(issue));
+}
+/**
+* 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 require_model_result.sdkErr({
+		...error,
+		refused: {
+			instant: void 0,
+			delayed: void 0
+		}
+	});
+}
+/**
+* The engine's answer, as the envelope the namespace speaks in: what the
+* operation comes to under `data`, stamped with the block it was computed
+* from, or the refusal as an error carrying its own numbers, see
+* {@link refusal}.
+*
+* 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, at) {
+	if (!result.ok) return refusal(result);
+	const { operations, state, calls } = result;
+	return require_model_result.sdkOk({
+		operations,
+		state,
+		calls,
+		...at
+	});
+}
+/**
+* {@inheritDoc planned}
+**/
+function opened(result, at) {
+	return result.ok ? require_model_result.sdkOk({
+		state: result.state,
+		...at
+	}) : refusal(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, at) {
+	if (!result.ok) {
+		const { refused, ...issue } = result;
+		return require_model_result.sdkErr({
+			...require_sdk_prepare_errors.toRefusalError(issue),
+			refused
+		});
+	}
+	const { instant, delayed, refused } = result;
+	return require_model_result.sdkOk({
+		instant: instant && {
+			operations: instant.operations,
+			state: instant.state,
+			calls: instant.calls,
+			...at
+		},
+		delayed: delayed && {
+			operations: delayed.operations,
+			state: delayed.state,
+			calls: delayed.calls,
+			delayed: delayed.delayed,
+			...at
+		},
+		refused,
+		...at
+	});
+}
+/**
 * 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,15 +519,18 @@ 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 require_model_result.sdkErr(require_sdk_prepare_errors.toRefusalError({
+		reason: "unsupportedTokenPair",
+		detail: {
+			from: require_onchain_validation_token.toToken(sdk, from),
+			to: to === void 0 ? void 0 : require_onchain_validation_token.toToken(sdk, to)
+		}
+	}));
 }
 /**
 * Picks the route the operation takes out of `tokenIn`, as a value rather than
 * an exception: an unroutable or ambiguous pair is a request the caller can
-* fix, so it belongs in the `ok: false` half alongside the strategy refusals.
+* fix, so it belongs in the failure half alongside the strategy refusals.
 *
 * A pool with no route out of the input reports it by throwing, hence the
 * catch; a requested output is checked against the list rather than trusted,

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

@@ -0,0 +1,93 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/sdk/prepare/errors.ts
+/**
+* One sentence per refusal, naming what was ruled out rather than restating the
+* numbers the error already carries.
+*
+* English and loggable, not a string to put on a screen: a form renders the
+* code and the amounts in its own words, see {@link IGearboxError.message}.
+**/
+const MESSAGES = {
+	debtOutOfRange: "The debt this request implies is outside the market's band.",
+	leverageOutOfRange: "The leverage asked for cannot be expressed as a plan.",
+	insufficientSourceBalance: "Neither the account nor the wallet holds enough to fund this request.",
+	unsupportedCollateralToken: "This flow does not accept that token.",
+	unsupportedTokenPair: "No route exists between these two tokens.",
+	noDelayedRoute: "This request cannot be served as a delayed redemption.",
+	multipleDelayedWithdrawals: "The source asset has several redemption venues and none was named.",
+	withdrawalInProgress: "A redemption of this asset is already in flight on the account.",
+	noRecordedIntent: "The claim names no operation to resume.",
+	marketPaused: "The market is paused.",
+	marketExpired: "The market is past its expiration date.",
+	insufficientPoolLiquidity: "The pool cannot lend what this plan draws.",
+	quotaLimitReached: "The market takes no more quota for a token this plan holds.",
+	forbiddenToken: "This plan would increase the balance of a forbidden token.",
+	insufficientCollateral: "The account would end this transaction under-collateralised.",
+	poolSunset: "The pool is winding down and takes no more deposits.",
+	quotaCountExceeded: "The account would hold more quoted tokens than the facade enables at once.",
+	malformedTransaction: "The transaction could not be replayed."
+};
+/**
+* The engine's refusal, as the error the namespace answers with.
+*
+* One place does the lifting, so the two shapes cannot drift: `reason` becomes
+* `code`, the detail is spread onto the error, and the sentence comes from
+* {@link MESSAGES}. A malformed transaction is spelled out rather than spread,
+* because its detail names a `code` and a `message` of its own and they are not
+* the envelope's.
+*
+* Generic over the issue it is handed, so a call site that already knows the
+* reason gets that reason's error back rather than a union to narrow again.
+**/
+function toRefusalError(issue) {
+	if (issue.reason === "malformedTransaction") return {
+		code: "malformedTransaction",
+		message: MESSAGES.malformedTransaction,
+		previewCode: issue.detail.code,
+		detail: issue.detail.message
+	};
+	return {
+		code: issue.reason,
+		message: MESSAGES[issue.reason],
+		...issue.detail
+	};
+}
+/**
+* {@inheritDoc NoStrategyTargetCollateralError}
+**/
+function noStrategyTargetCollateral(creditManager) {
+	return {
+		code: "noStrategyTargetCollateral",
+		message: `Credit manager ${creditManager} has no strategy target collateral, and none was named.`,
+		creditManager
+	};
+}
+/**
+* {@inheritDoc CreditAccountNotFoundError}
+**/
+function creditAccountNotFound(creditAccount) {
+	return {
+		code: "creditAccountNotFound",
+		message: `Credit account not found: ${creditAccount}.`,
+		creditAccount
+	};
+}
+/**
+* {@inheritDoc UnexpectedFailureError}
+*
+* Takes what was thrown, whatever that is: a `throw` is not obliged to raise an
+* `Error`, and `cause` promises one.
+**/
+function unexpectedFailure(thrown) {
+	const cause = thrown instanceof Error ? thrown : new Error(String(thrown));
+	return {
+		code: "unexpectedFailure",
+		message: `The SDK could not prepare this operation: ${cause.message}`,
+		cause
+	};
+}
+//#endregion
+exports.creditAccountNotFound = creditAccountNotFound;
+exports.noStrategyTargetCollateral = noStrategyTargetCollateral;
+exports.toRefusalError = toRefusalError;
+exports.unexpectedFailure = unexpectedFailure;

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

@@ -1,8 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_validation_refusal = require("../../onchain/validation/refusal.js");
+const require_sdk_prepare_errors = require("./errors.js");
 const require_sdk_prepare_PrepareApi = require("./PrepareApi.js");
 require("./types.js");
 exports.IntentPreviewError = require_onchain_validation_refusal.IntentPreviewError;
 exports.PrepareApi = require_sdk_prepare_PrepareApi.PrepareApi;
+exports.creditAccountNotFound = require_sdk_prepare_errors.creditAccountNotFound;
+exports.noStrategyTargetCollateral = require_sdk_prepare_errors.noStrategyTargetCollateral;
 exports.raise = require_onchain_validation_refusal.raise;
 exports.refuse = require_onchain_validation_refusal.refuse;
+exports.toRefusalError = require_sdk_prepare_errors.toRefusalError;
+exports.unexpectedFailure = require_sdk_prepare_errors.unexpectedFailure;

package/dist/esm/model/errors.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/model/index.js

@@ -5,6 +5,7 @@ import { chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chart
 import "./curators.js";
 import { curatorNameSchema, curatorSchema } from "./curators.schema.js";
 import "./delayed-intents.js";
+import "./errors.js";
 import { FILTER_ALL, isFilterSet } from "./filters.js";
 import { booleanParamSchema, encodeFlag, filterAllSchema, filterable } from "./filters.schema.js";
 import { matchesLiquidatableAccountFilter } from "./liquidations.js";
@@ -19,6 +20,7 @@ import { ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ER
 import "./primitives.js";
 import "./response.js";
 import { chainFailedSchema, chainMetadataSchema, chainSucceededSchema, dataSourceSchema, responseMetadataSchema, responseSchema } from "./response.schema.js";
+import { isSDKError, sdkErr, sdkOk } from "./result.js";
 import "./withdrawals.js";
 import { positionClaimableWithdrawalSchema, positionPendingWithdrawalSchema, positionWithdrawalsSchema } from "./withdrawals.schema.js";
-export { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPRICEABLE_TOKEN, ERROR_UNSUPPORTED_OUT_OF_BRACKET_CALL, FILTER_ALL, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, amountSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, instantReceivedAssetSchema, isFilterSet, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema };
+export { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPRICEABLE_TOKEN, ERROR_UNSUPPORTED_OUT_OF_BRACKET_CALL, FILTER_ALL, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, amountSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, instantReceivedAssetSchema, isFilterSet, isSDKError, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, sdkErr, sdkOk, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema };

package/dist/esm/model/result.js

@@ -0,0 +1,24 @@
+//#region src/model/result.ts
+/** The success half, built. */
+function sdkOk(data) {
+	return {
+		ok: true,
+		data
+	};
+}
+/** The failure half, built. */
+function sdkErr(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+/**
+* Narrows a {@link SDKReturn} to its failure half. Trivial over `ok`, but it
+* names the intent at call sites that would otherwise read `!r.ok`.
+**/
+function isSDKError(answer) {
+	return !answer.ok;
+}
+//#endregion
+export { isSDKError, sdkErr, sdkOk };

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

@@ -10,7 +10,7 @@ import "./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/esm/onchain/accounts/intents/tail.js

@@ -53,7 +53,7 @@ async function projectTail(args) {
 	const { request, delayed, creditAccount, sdk, quotaReserve } = args;
 	const { claim } = delayed;
 	const queued = request.outputs.find((o) => o.isDelayed);
-	if (!queued || !claim) throw new Error("projectTail: the request queued nothing to claim");
+	if (!queued || !claim) throw new IntentPreviewError("noRecordedIntent", void 0, "projectTail: the request queued nothing to claim");
 	const next = sliceAfter(creditAccount, delayed.afterRequest);
 	const steps = planTail({
 		intent: delayed.record,