@gearbox-protocol/sdk 16.0.0-next.8 → 16.0.0

package/dist/esm/onchain/positions/calcLiquidationPrice.js

@@ -10,13 +10,22 @@ import { isAddressEqual } from "viem";
 * holds exactly one non-dust non-underlying asset; otherwise `null`.
 **/
 function calcLiquidationPrice(props) {
-	const { snapshot, underlying } = props;
-	const targets = snapshot.assets.filter((a) => a.balance > 10n && !isAddressEqual(a.token, underlying));
-	if (targets.length !== 1) return null;
+	const targetToken = soleNonUnderlyingCollateral(props.snapshot, props.underlying);
+	if (!targetToken) return null;
 	return calcLiquidationPriceForTarget({
 		...props,
-		targetToken: targets[0].token
+		targetToken
 	});
 }
+/**
+* The one collateral a liquidation price — and the current price beside it —
+* can be quoted for: the account's single non-dust, non-underlying asset.
+* `null` when it holds none or several, which is the case neither figure
+* exists for.
+**/
+function soleNonUnderlyingCollateral(snapshot, underlying) {
+	const targets = snapshot.assets.filter((a) => a.balance > 10n && !isAddressEqual(a.token, underlying));
+	return targets.length === 1 ? targets[0].token : null;
+}
 //#endregion
-export { calcLiquidationPrice };
+export { calcLiquidationPrice, soleNonUnderlyingCollateral };

package/dist/esm/onchain/positions/index.js

@@ -1,9 +1,9 @@
 import { calcBorrowRate } from "./calcBorrowRate.js";
 import { calcHealthFactor } from "./calcHealthFactor.js";
 import { calcLiquidationPriceForTarget } from "./calcLiquidationPriceForTarget.js";
-import { calcLiquidationPrice } from "./calcLiquidationPrice.js";
+import { calcLiquidationPrice, soleNonUnderlyingCollateral } from "./calcLiquidationPrice.js";
 import { calcTimeToLiquidationMs } from "./calcTimeToLiquidationMs.js";
 import { MultichainPositionsService } from "./MultichainPositionsService.js";
 import { accountSnapshotFromCreditAccountData } from "./types.js";
 import { PositionsService } from "./PositionsService.js";
-export { MultichainPositionsService, PositionsService, accountSnapshotFromCreditAccountData, calcBorrowRate, calcHealthFactor, calcLiquidationPrice, calcLiquidationPriceForTarget, calcTimeToLiquidationMs };
+export { MultichainPositionsService, PositionsService, accountSnapshotFromCreditAccountData, calcBorrowRate, calcHealthFactor, calcLiquidationPrice, calcLiquidationPriceForTarget, calcTimeToLiquidationMs, soleNonUnderlyingCollateral };

package/dist/esm/onchain/router/AbstractRouterContract.js

@@ -85,7 +85,7 @@ var AbstractRouterContract = class extends BaseContract {
 			leftoverBalances.upsert(token, limitLeftover(balance, token) ?? balance);
 			if (isEnabled && !keepAssets.has(token)) usdBalances.push({
 				token,
-				balance: this.safeConvertToUSD(priceOracle, token, balance)
+				balance: priceOracle.safeConvertToUSD(token, balance).value
 			});
 		}
 		usdBalances.sort((a, b) => {
@@ -98,7 +98,7 @@ var AbstractRouterContract = class extends BaseContract {
 		const lt = this.sdk.marketRegister.findCreditManager(ca.creditManager).creditManager.liquidationThresholds.mustGet(highestToken.token);
 		const requiredDebtUSD = ca.totalDebtUSD * PERCENTAGE_FACTOR / BigInt(lt);
 		if (highestToken.balance < requiredDebtUSD) return;
-		const tokenAmount = this.safeConvertFromUSD(priceOracle, highestToken.token, requiredDebtUSD);
+		const tokenAmount = priceOracle.safeConvertFromUSD(highestToken.token, requiredDebtUSD).value;
 		if (tokenAmount === 0n) return;
 		let leftoverBalance = leftoverBalances.get(highestToken.token) ?? 0n;
 		leftoverBalance -= tokenAmount;
@@ -113,28 +113,6 @@ var AbstractRouterContract = class extends BaseContract {
 			tokensToClaim: new AssetsMap()
 		};
 	}
-	safeConvertToUSD(priceOracle, token, balance) {
-		try {
-			return priceOracle.convertToUSD(token, balance);
-		} catch {
-			try {
-				return priceOracle.convertToUSD(token, balance, true);
-			} catch {
-				return 0n;
-			}
-		}
-	}
-	safeConvertFromUSD(priceOracle, token, balance) {
-		try {
-			return priceOracle.convertFromUSD(token, balance);
-		} catch {
-			try {
-				return priceOracle.convertFromUSD(token, balance, true);
-			} catch {
-				return 0n;
-			}
-		}
-	}
 };
 //#endregion
 export { AbstractRouterContract };

package/dist/esm/onchain/router/RouterV310Contract.js

@@ -227,7 +227,7 @@ var RouterV310Contract = class extends AbstractRouterContract {
 		}).map(({ token, balance }) => {
 			return {
 				token,
-				balance: this.#convertToUSDForSort(priceOracle, token, balance)
+				balance: priceOracle.safeConvertToUSD(token, balance).value
 			};
 		}).sort((a, b) => {
 			return a.balance > b.balance ? -1 : 1;
@@ -240,17 +240,6 @@ var RouterV310Contract = class extends AbstractRouterContract {
 		for (const [token, numSplits] of this.#numSplits.entries()) map.upsert(token, numSplits);
 		return (token) => map.get(token) ?? 1n;
 	}
-	/**
-	* Tries to get some value even when prices are broken, since it's only needed for sorting
-	* @param oracle
-	* @param token
-	* @param amount
-	* @returns
-	*/
-	#convertToUSDForSort(oracle, token, amount) {
-		const scale = 10n ** BigInt(this.tokensMeta.get(token)?.decimals ?? 0);
-		return amount * (oracle.mainPrices.get(token)?.price || oracle.reservePrices.get(token)?.price || scale) / scale;
-	}
 	#debugTokenData(tData) {
 		return tData.map((t) => ({
 			token: this.labelAddress(t.token),

package/dist/esm/onchain/utils/index.js

@@ -15,6 +15,7 @@ import { fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage,
 import { hexEq } from "./hex.js";
 import { retry } from "./retry.js";
 import { toAddress } from "./toAddress.js";
+import { EXECUTE_BYTES_SELECTOR, collectTraces, findCallTo, findCallWithInput, findExecuteBytes, resolveProtocolCall } from "./trace.js";
 import "./type-utils.js";
 import { ZodAddress, ZodBigInt, ZodHex } from "./zod.js";
-export { AddressMap, AddressSet, AssetsMap, BigIntMath, TypedObjectUtils, ZodAddress, ZodBigInt, ZodHex, bytes32ToString, childLogger, createRawTx, etherscanApiUrl, etherscanUrl, filterDust, filterDustUSD, fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage, formatNumberToString_, formatPercentage, formatTimestamp, functionArgsToMap, functionArgsToRecord, getFunctionSignature, hexEq, isDust, json_parse, json_stringify, numberWithCommas, percentFmt, rayToNumber, retry, shortAddress, shortHash, toAddress, toBN, toBigInt, toSignificant };
+export { AddressMap, AddressSet, AssetsMap, BigIntMath, EXECUTE_BYTES_SELECTOR, TypedObjectUtils, ZodAddress, ZodBigInt, ZodHex, bytes32ToString, childLogger, collectTraces, createRawTx, etherscanApiUrl, etherscanUrl, filterDust, filterDustUSD, findCallTo, findCallWithInput, findExecuteBytes, fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage, formatNumberToString_, formatPercentage, formatTimestamp, functionArgsToMap, functionArgsToRecord, getFunctionSignature, hexEq, isDust, json_parse, json_stringify, numberWithCommas, percentFmt, rayToNumber, resolveProtocolCall, retry, shortAddress, shortHash, toAddress, toBN, toBigInt, toSignificant };

package/dist/esm/{common-utils → onchain}/utils/trace.js

@@ -1,5 +1,5 @@
 import { decodeAbiParameters, getAddress, isAddressEqual } from "viem";
-//#region src/common-utils/utils/trace.ts
+//#region src/onchain/utils/trace.ts
 /**
 * Selector of `CreditManagerV3.execute(bytes)` (`0x09c5eabe`).
 *

package/dist/esm/onchain/utils/viem/simulateWithPriceUpdates.js

@@ -1,6 +1,6 @@
 import { errorAbis } from "../../../abi/errors.js";
-import { iUpdatablePriceFeedAbi } from "../../../abi/iUpdatablePriceFeed.js";
 import { generateCastTraceCall } from "./cast.js";
+import { iUpdatablePriceFeedAbi } from "../../../abi/iUpdatablePriceFeed.js";
 import { simulateMulticall } from "./simulateMulticall.js";
 import { BaseError, CallExecutionError, ContractFunctionRevertedError, decodeFunctionData, decodeFunctionResult, encodeFunctionData, parseAbi } from "viem";
 import { getAction, parseAccount } from "viem/utils";

package/dist/esm/onchain/validation/checks.js

@@ -0,0 +1,238 @@
+//#region src/onchain/validation/checks.ts
+/**
+* Every refusal the protocol can pass on an operation, as values.
+*
+* Each check is handed the numbers it compares — never a suite, a market or an
+* SDK — so the engine, `checkOperation` and the strategy lists share one
+* implementation.
+*
+* Ladders stay with the caller because they differ deliberately: the engine
+* reports the tightest ceiling it found, the account-opening path the first one
+* exceeded in its own order.
+*/
+/** A factor at or below this is refused; kept for the callers that size on it. */
+const MIN_HF_LIMITED = 10100n;
+/** The same bar as a `required` argument — the lowest factor that passes. */
+const MIN_HEALTH_FACTOR_FORM = 10101;
+/** The bar the facade itself enforces: an account may end exactly at 1.0. */
+const MIN_HEALTH_FACTOR_FACADE = 1e4;
+/**
+* The safe-price bar a form holds an account to. A step above the facade's,
+* because a factor of exactly 1.0 at safe prices is already a refusal.
+*/
+const MIN_SAFE_HEALTH_FACTOR_FORM = 10001;
+/** A refusal names what a limit was measured in, never what it is worth. */
+function amountOf(token, value) {
+	return {
+		token,
+		value,
+		valueUsd: null
+	};
+}
+/** The credit manager takes no multicall while it is paused. */
+function checkCreditManagerPaused(args) {
+	if (!args.isPaused) return null;
+	return {
+		reason: "marketPaused",
+		detail: { creditManager: args.creditManager }
+	};
+}
+/** Past its expiration date the facade takes no more multicalls. */
+function checkMarketExpired(args) {
+	if (!args.isExpired) return null;
+	return {
+		reason: "marketExpired",
+		detail: {
+			creditManager: args.creditManager,
+			expirationDate: args.expirationDate
+		}
+	};
+}
+/** A paused pool neither takes deposits nor pays out. */
+function checkPoolPaused(args) {
+	return args.isPaused ? {
+		reason: "marketPaused",
+		detail: { pool: args.pool }
+	} : null;
+}
+/**
+* A pool winding down still pays out, so only what puts money in is refused.
+*/
+function checkPoolSunset(args) {
+	return args.isSunset && args.isDeposit ? {
+		reason: "poolSunset",
+		detail: { pool: args.pool }
+	} : null;
+}
+/**
+* What the pool will hand over, against what is asked for.
+*
+* `binding` and `available` are the caller's answer to "which ceiling stands in
+* the way", not this check's: see the ladder note above. `solutionAmount` is
+* the largest position still openable, left out when none is.
+*/
+function checkBorrowLimit(args) {
+	if (args.requested <= args.available) return null;
+	return {
+		reason: "insufficientPoolLiquidity",
+		detail: {
+			requested: amountOf(args.underlying, args.requested),
+			available: amountOf(args.underlying, args.available),
+			binding: args.binding,
+			...args.solutionAmount === void 0 ? {} : { solutionAmount: amountOf(args.underlying, args.solutionAmount) }
+		}
+	};
+}
+/**
+* What the pool can pay out, against what is being taken out.
+*
+* The operator is not `checkBorrowLimit`'s: a pool holding exactly the amount
+* asked for still cannot serve it, so equality is already a refusal. That is
+* the rule the legacy withdrawal validator enforced and it is preserved to the
+* unit.
+*/
+function checkPoolPayout(args) {
+	if (args.requested < args.available) return null;
+	return {
+		reason: "insufficientPoolLiquidity",
+		detail: {
+			requested: amountOf(args.underlying, args.requested),
+			available: amountOf(args.underlying, args.available),
+			binding: "poolAvailableLiquidity"
+		}
+	};
+}
+/**
+* A debt the facade would revert on.
+*
+* `allowZero` is the one place the two callers genuinely disagree: an account
+* being adjusted may end owing nothing, while one being opened may not — so the
+* exemption is stated rather than assumed.
+*/
+function checkDebtInBand(args) {
+	const { debt, minDebt, maxDebt, underlying, allowZero } = args;
+	if (!(debt > maxDebt || debt < minDebt && !(allowZero && debt === 0n))) return null;
+	return {
+		reason: "debtOutOfRange",
+		detail: {
+			requested: amountOf(underlying, debt),
+			minDebt: amountOf(underlying, minDebt),
+			maxDebt: amountOf(underlying, maxDebt)
+		}
+	};
+}
+/** Leverage below 1x is not a position, it is a withdrawal. */
+function checkLeverageAtLeastOne(args) {
+	return args.leverage < args.min ? {
+		reason: "leverageOutOfRange",
+		detail: {
+			requested: args.leverage,
+			min: args.min
+		}
+	} : null;
+}
+/**
+* The account against its debt, at whichever bar the caller holds it to.
+*
+* An unread factor counts as failing: a check that cannot see the number is not
+* evidence that the number is fine.
+*/
+function checkCollateralised(args) {
+	const { healthFactor, required, safePrices, improvesFrom } = args;
+	if (healthFactor === void 0) return {
+		reason: "insufficientCollateral",
+		detail: {
+			healthFactor: 0,
+			required,
+			safePrices
+		}
+	};
+	if (healthFactor >= required || improvesFrom !== void 0 && healthFactor > improvesFrom) return null;
+	return {
+		reason: "insufficientCollateral",
+		detail: {
+			healthFactor,
+			required,
+			safePrices
+		}
+	};
+}
+/** A token the market will not let the account hold. */
+function checkForbiddenToken(args) {
+	return args.isForbidden ? {
+		reason: "forbiddenToken",
+		detail: { token: args.token }
+	} : null;
+}
+/**
+* The room the keeper still has for a token's quota, in the underlying.
+*
+* `requested` is absent for a token the market opened no quota for at all —
+* nothing was weighed against a limit, the token simply counts as no collateral.
+*/
+function checkQuotaLimit(args) {
+	const { token, requested, available, underlying } = args;
+	if (requested !== void 0 && requested <= available) return null;
+	return {
+		reason: "quotaLimitReached",
+		detail: {
+			token,
+			requested: requested === void 0 ? void 0 : amountOf(underlying, requested),
+			available: amountOf(underlying, available)
+		}
+	};
+}
+/** How many quoted tokens the facade enables at once. */
+function checkQuotaCount(args) {
+	return args.count > args.max ? {
+		reason: "quotaCountExceeded",
+		detail: {
+			count: args.count,
+			max: args.max
+		}
+	} : null;
+}
+/** What the operation is funded from, against what is there. */
+function checkFunding(args) {
+	const { token, required, held } = args;
+	if (required <= held) return null;
+	return {
+		reason: "insufficientSourceBalance",
+		detail: {
+			required: amountOf(token, required),
+			held: amountOf(token, held)
+		}
+	};
+}
+/**
+* The SDK could not replay the transaction.
+*
+* Only a {@link MalformedPreviewError} lands here. An `unpriceableToken`
+* warning says the transaction is fine and the SDK could not fully evaluate
+* it, which is a caveat on the numbers rather than a reason to refuse — it
+* stays on the preview for the caller to surface.
+*/
+function checkPreviewError(warning) {
+	if (!warning || !isMalformedPreviewError(warning)) return null;
+	return {
+		reason: "malformedTransaction",
+		detail: warning
+	};
+}
+/**
+* Whether the preview warning means the transaction itself is malformed,
+* rather than that only the evaluation was incomplete.
+*/
+function isMalformedPreviewError(warning) {
+	switch (warning.code) {
+		case "malformedBracket":
+		case "adapterCallOutsideBracket":
+		case "nonAdapterCallInBracket":
+		case "unpreviewableAdapterCall":
+		case "unsupportedOutOfBracketCall":
+		case "invalidTransactionValue": return true;
+		default: return false;
+	}
+}
+//#endregion
+export { MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM, amountOf, checkBorrowLimit, checkCollateralised, checkCreditManagerPaused, checkDebtInBand, checkForbiddenToken, checkFunding, checkLeverageAtLeastOne, checkMarketExpired, checkPoolPaused, checkPoolPayout, checkPoolSunset, checkPreviewError, checkQuotaCount, checkQuotaLimit, isMalformedPreviewError };

package/dist/esm/onchain/validation/index.js

@@ -0,0 +1,4 @@
+import { MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM, amountOf, checkBorrowLimit, checkCollateralised, checkCreditManagerPaused, checkDebtInBand, checkForbiddenToken, checkFunding, checkLeverageAtLeastOne, checkMarketExpired, checkPoolPaused, checkPoolPayout, checkPoolSunset, checkPreviewError, checkQuotaCount, checkQuotaLimit, isMalformedPreviewError } from "./checks.js";
+import { raise, refuse } from "./refusal.js";
+import { toToken, toTokenAmount } from "./token.js";
+export { MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM, amountOf, checkBorrowLimit, checkCollateralised, checkCreditManagerPaused, checkDebtInBand, checkForbiddenToken, checkFunding, checkLeverageAtLeastOne, checkMarketExpired, checkPoolPaused, checkPoolPayout, checkPoolSunset, checkPreviewError, checkQuotaCount, checkQuotaLimit, isMalformedPreviewError, raise, refuse, toToken, toTokenAmount };

package/dist/esm/onchain/validation/refusal.js

@@ -0,0 +1,36 @@
+//#region src/onchain/validation/refusal.ts
+/** Builds the refusal a caller sees. */
+function refuse(reason, detail) {
+	return {
+		ok: false,
+		reason,
+		detail
+	};
+}
+/**
+* Validation failure that maps onto {@link PreviewErrorReason} rather than
+* crashing the caller: raised by the planners and the guards, turned into
+* `{ ok: false }` by `CreditAccountOperationsService`.
+*/
+var IntentPreviewError = class extends Error {
+	reason;
+	detail;
+	constructor(reason, detail, message) {
+		super(message ?? reason);
+		this.name = "IntentPreviewError";
+		this.reason = reason;
+		this.detail = detail;
+	}
+};
+/**
+* Throws the issue a check found, with the sentence the engine logs for it.
+*
+* Returns normally when there is nothing to raise, so it cannot narrow a type
+* the way a bare `throw` does — a site that guards a value for the code below
+* it keeps throwing directly.
+*/
+function raise(issue, message) {
+	if (issue) throw new IntentPreviewError(issue.reason, issue.detail, message);
+}
+//#endregion
+export { IntentPreviewError, raise, refuse };

package/dist/esm/onchain/validation/token.js

@@ -0,0 +1,27 @@
+import { shortAddress } from "../utils/formatter.js";
+import { amountOf } from "./checks.js";
+//#region src/onchain/validation/token.ts
+/**
+* The token behind an address, for the refusal details that inline one.
+*
+* A token the registry does not know falls back to its own shortened address
+* as a symbol and `decimals: 0` — an unknown token has no scale, and guessing
+* 18 would silently misformat every amount denominated in it.
+*/
+function toToken(sdk, address) {
+	const known = sdk.tokensMeta.getToken(address);
+	if (known) return known;
+	return {
+		chainId: sdk.chainId,
+		address,
+		symbol: shortAddress(address),
+		name: "",
+		decimals: 0
+	};
+}
+/** {@link toToken} plus an amount denominated in it. */
+function toTokenAmount(sdk, address, value) {
+	return amountOf(toToken(sdk, address), value);
+}
+//#endregion
+export { toToken, toTokenAmount };

package/dist/esm/permissionless/bindings/instance-manager.js

@@ -133,6 +133,22 @@ var InstanceManagerContract = class extends BaseContract {
 					saveVersion: saveVersion ? "true" : "false"
 				};
 			}
+			case "setGlobalAddress": {
+				const [key, address, saveVersion] = params.args;
+				return {
+					key: hexToString(key, { size: 32 }),
+					address,
+					saveVersion: saveVersion ? "true" : "false"
+				};
+			}
+			case "setLocalAddress": {
+				const [key, address, saveVersion] = params.args;
+				return {
+					key: hexToString(key, { size: 32 }),
+					address,
+					saveVersion: saveVersion ? "true" : "false"
+				};
+			}
 			default: return super.parseFunctionParams(params);
 		}
 	}

package/dist/esm/preview/index.js

@@ -1,11 +1,10 @@
-import { UnsupportedZapperFunctionError } from "../onchain/market/zapper/errors.js";
+import { raise, refuse } from "../onchain/validation/refusal.js";
 import { TransferAlignmentError, UnexpectedFacadeEventOrderError, UnknownAdapterError, UnknownFacadeCallError, WithdrawCollateralAlignmentError } from "./trace/errors.js";
 import { extractAdapterCallTraces } from "./trace/extractAdapterCallTraces.js";
 import { extractTransfers } from "./trace/extractTransfers.js";
 import { findFacadeCalls } from "./trace/findFacadeCalls.js";
 import "./trace/index.js";
 import { classifyInnerOperations } from "./parse/classifyInnerOperations.js";
-import { UnsupportedPoolFunctionError, UnsupportedTargetError } from "./parse/errors.js";
 import { parseFacadeOperationCalldata } from "./parse/parseFacadeOperationCalldata.js";
 import { parsePoolOperationCalldata } from "./parse/parsePoolOperationCalldata.js";
 import { parseRWAFactoryOperationCalldata } from "./parse/parseRWAFactoryOperationCalldata.js";
@@ -18,17 +17,22 @@ import { BalancePrerequisite } from "./prerequisites/BalancePrerequisite.js";
 import { RWAOpenRequirementsPrerequisite } from "./prerequisites/RWAOpenRequirementsPrerequisite.js";
 import { checkPrerequisites } from "./prerequisites/checkPrerequisites.js";
 import "./prerequisites/index.js";
-import { buildDelayedPreview } from "./preview/buildDelayedPreview.js";
+import { buildDelayedStrategyPositionOperationPreview } from "./preview/buildDelayedStrategyPositionOperationPreview.js";
 import { CreditAccountState } from "./preview/CreditAccountState.js";
 import { classifyCloseOrRepay, isCloseOrRepay } from "./preview/detectCloseOrRepay.js";
 import { detectDelayedClaim, resolveDelayedClaimIntent } from "./preview/detectDelayedClaim.js";
 import { detectDelayedOperation } from "./preview/detectDelayedOperation.js";
-import { UnsupportedOperationError } from "./preview/errors.js";
+import { adapterCallOutsideBracketError, invalidTransactionValueError, malformedBracketError, nonAdapterCallInBracketError, unpreviewableAdapterCallError, unsupportedOutOfBracketCallError } from "./preview/errors.js";
+import { estimateClaimableAt } from "./preview/estimateClaimableAt.js";
 import { makeReplayState, replayInnerOperations } from "./preview/replayInnerOperations.js";
 import { replayMulticall } from "./preview/replayMulticall.js";
-import { previewAdjustCreditAccount } from "./preview/previewAdjustCreditAccount.js";
-import { previewCloseOrRepayCreditAccount } from "./preview/previewCloseOrRepayCreditAccount.js";
+import { previewAdjustStrategyPosition } from "./preview/previewAdjustStrategyPosition.js";
+import { previewExitOrRepayStrategyPosition } from "./preview/previewExitOrRepayStrategyPosition.js";
+import { asPreviewSimulationError } from "./simulate/errors.js";
 import { previewOperation } from "./preview/previewOperation.js";
 import "./preview/index.js";
 import "./types.js";
-export { AllowancePrerequisite, BalancePrerequisite, CreditAccountState, Prerequisite, RWAOpenRequirementsPrerequisite, TransferAlignmentError, UnexpectedFacadeEventOrderError, UnknownAdapterError, UnknownFacadeCallError, UnsupportedOperationError, UnsupportedPoolFunctionError, UnsupportedTargetError, UnsupportedZapperFunctionError, WithdrawCollateralAlignmentError, buildDelayedPreview, checkPrerequisites, classifyCloseOrRepay, classifyInnerOperations, detectDelayedClaim, detectDelayedOperation, extractAdapterCallTraces, extractTransfers, findFacadeCalls, isCloseOrRepay, isPoolOperation, isRWAOperation, makeReplayState, parseFacadeOperationCalldata, parseOperationCalldata, parsePoolOperationCalldata, parseRWAFactoryOperationCalldata, previewAdjustCreditAccount, previewCloseOrRepayCreditAccount, previewOperation, replayInnerOperations, replayMulticall, resolveDelayedClaimIntent };
+import { checkOperation, collateralIssue, marketIssues, quotaCountIssue } from "./validate/checkOperation.js";
+import { checkSimulation } from "./validate/checkSimulation.js";
+import "./validate/index.js";
+export { AllowancePrerequisite, BalancePrerequisite, CreditAccountState, Prerequisite, RWAOpenRequirementsPrerequisite, TransferAlignmentError, UnexpectedFacadeEventOrderError, UnknownAdapterError, UnknownFacadeCallError, WithdrawCollateralAlignmentError, adapterCallOutsideBracketError, asPreviewSimulationError, buildDelayedStrategyPositionOperationPreview, checkOperation, checkPrerequisites, checkSimulation, classifyCloseOrRepay, classifyInnerOperations, collateralIssue, detectDelayedClaim, detectDelayedOperation, estimateClaimableAt, extractAdapterCallTraces, extractTransfers, findFacadeCalls, invalidTransactionValueError, isCloseOrRepay, isPoolOperation, isRWAOperation, makeReplayState, malformedBracketError, marketIssues, nonAdapterCallInBracketError, parseFacadeOperationCalldata, parseOperationCalldata, parsePoolOperationCalldata, parseRWAFactoryOperationCalldata, previewAdjustStrategyPosition, previewExitOrRepayStrategyPosition, previewOperation, quotaCountIssue, raise, refuse, replayInnerOperations, replayMulticall, resolveDelayedClaimIntent, unpreviewableAdapterCallError, unsupportedOutOfBracketCallError };

package/dist/esm/preview/parse/errors.js

@@ -1,30 +1 @@
-import { UnsupportedZapperFunctionError } from "../../onchain/market/zapper/errors.js";
-import "../../onchain/index.js";
-//#region src/preview/parse/errors.ts
-/**
-* Thrown when the target of a transaction is neither a known Gearbox pool nor a
-* credit facade.
-*/
-var UnsupportedTargetError = class extends Error {
-	target;
-	constructor(target) {
-		super(`unsupported transaction target: ${target}`);
-		this.name = "UnsupportedTargetError";
-		this.target = target;
-	}
-};
-/**
-* Thrown when a pool call uses a function other than ERC4626 `deposit`/`redeem`.
-*/
-var UnsupportedPoolFunctionError = class extends Error {
-	pool;
-	functionName;
-	constructor(pool, functionName) {
-		super(`unsupported pool function "${functionName}" on ${pool}`);
-		this.name = "UnsupportedPoolFunctionError";
-		this.pool = pool;
-		this.functionName = functionName;
-	}
-};
-//#endregion
-export { UnsupportedPoolFunctionError, UnsupportedTargetError, UnsupportedZapperFunctionError };
+export {};

package/dist/esm/preview/parse/index.js

@@ -1,9 +1,8 @@
-import { UnsupportedZapperFunctionError } from "../../onchain/market/zapper/errors.js";
 import { classifyInnerOperations } from "./classifyInnerOperations.js";
-import { UnsupportedPoolFunctionError, UnsupportedTargetError } from "./errors.js";
+import "./errors.js";
 import { parseFacadeOperationCalldata } from "./parseFacadeOperationCalldata.js";
 import { parsePoolOperationCalldata } from "./parsePoolOperationCalldata.js";
 import { parseRWAFactoryOperationCalldata } from "./parseRWAFactoryOperationCalldata.js";
 import { parseOperationCalldata } from "./parseOperationCalldata.js";
 import { isPoolOperation, isRWAOperation } from "./types.js";
-export { UnsupportedPoolFunctionError, UnsupportedTargetError, UnsupportedZapperFunctionError, classifyInnerOperations, isPoolOperation, isRWAOperation, parseFacadeOperationCalldata, parseOperationCalldata, parsePoolOperationCalldata, parseRWAFactoryOperationCalldata };
+export { classifyInnerOperations, isPoolOperation, isRWAOperation, parseFacadeOperationCalldata, parseOperationCalldata, parsePoolOperationCalldata, parseRWAFactoryOperationCalldata };

package/dist/esm/preview/parse/parseOperationCalldata.js

@@ -1,9 +1,10 @@
 import { CreditFacadeV310Contract } from "../../onchain/market/credit/CreditFacadeV310Contract.js";
+import { isSDKError, sdkErr, sdkOk } from "../../model/result.js";
+import "../../model/index.js";
 import { PoolV310Contract } from "../../onchain/market/pool/PoolV310Contract.js";
 import { ZapperContract } from "../../onchain/market/zapper/ZapperContract.js";
 import { isRWAFactory } from "../../onchain/market/rwa/types.js";
 import "../../onchain/index.js";
-import { UnsupportedTargetError } from "./errors.js";
 import { parseFacadeOperationCalldata } from "./parseFacadeOperationCalldata.js";
 import { parsePoolOperationCalldata } from "./parsePoolOperationCalldata.js";
 import { parseRWAFactoryOperationCalldata } from "./parseRWAFactoryOperationCalldata.js";
@@ -19,19 +20,24 @@ function parseOperationCalldata(input) {
 	const contract = sdk.getContract(to);
 	if (contract instanceof PoolV310Contract) return parsePoolOperationCalldata(sdk, contract, calldata);
 	if (contract instanceof ZapperContract) {
-		const parsed = contract.parseOperation(calldata, value);
-		if (parsed.operation === "Deposit") return {
-			operation: "Deposit",
-			pool: parsed.pool,
-			receiver: parsed.receiver,
-			assets: parsed.assets,
-			underlying: parsed.underlying,
-			tokenIn: contract.tokenIn.addr,
-			tokenOut: contract.tokenOut.addr,
-			zapper: parsed.zapper,
-			referralCode: parsed.referralCode
-		};
-		return {
+		const answer = contract.parseOperation(calldata, value);
+		if (isSDKError(answer)) return answer;
+		const parsed = answer.data;
+		if (parsed.operation === "Deposit") {
+			const op = {
+				operation: "Deposit",
+				pool: parsed.pool,
+				receiver: parsed.receiver,
+				assets: parsed.assets,
+				underlying: parsed.underlying,
+				tokenIn: contract.tokenIn.addr,
+				tokenOut: contract.tokenOut.addr,
+				zapper: parsed.zapper,
+				referralCode: parsed.referralCode
+			};
+			return sdkOk(op);
+		}
+		const op = {
 			operation: "Redeem",
 			pool: parsed.pool,
 			receiver: parsed.receiver,
@@ -42,10 +48,15 @@ function parseOperationCalldata(input) {
 			tokenOut: contract.tokenIn.addr,
 			zapper: parsed.zapper
 		};
+		return sdkOk(op);
 	}
-	if (contract instanceof CreditFacadeV310Contract) return parseFacadeOperationCalldata(sdk, contract, calldata);
-	if (contract && isRWAFactory(contract)) return parseRWAFactoryOperationCalldata(sdk, contract, calldata);
-	throw new UnsupportedTargetError(to);
+	if (contract instanceof CreditFacadeV310Contract) return sdkOk(parseFacadeOperationCalldata(sdk, contract, calldata));
+	if (contract && isRWAFactory(contract)) return sdkOk(parseRWAFactoryOperationCalldata(sdk, contract, calldata));
+	return sdkErr({
+		code: "unsupportedTarget",
+		message: `unsupported transaction target: ${to}`,
+		target: to
+	});
 }
 //#endregion
 export { parseOperationCalldata };