@panoptic-eng/sdk 1.0.60 → 1.0.62

package/dist/uniswap/index.js

@@ -1,5 +1,5 @@
 import Decimal from "decimal.js";
-import { BaseError, ContractFunctionRevertedError, decodeAbiParameters, decodeEventLog, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, getAbiItem, isAddressEqual, keccak256, maxUint256, parseAbi, toFunctionSelector, zeroAddress } from "viem";
+import { BaseError, ContractFunctionRevertedError, decodeAbiParameters, decodeErrorResult, decodeEventLog, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, getAbiItem, isAddressEqual, keccak256, maxUint256, parseAbi, toFunctionSelector, zeroAddress } from "viem";
 
 //#region src/uniswap/estimateLpFees.ts
 const D$1 = Decimal.clone({ precision: 60 });
@@ -230,6 +230,483 @@ var PanopticError = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/panoptic/v2/errors/contract.ts
+/**
+* The account is not solvent enough to perform the desired action.
+* @see Errors.sol:9
+*/
+var AccountInsolventError = class extends PanopticError {
+	name = "AccountInsolventError";
+	constructor(solvent, numberOfTicks, cause) {
+		super(`Account insolvent: solvent=${solvent}, numberOfTicks=${numberOfTicks}`, cause);
+		this.solvent = solvent;
+		this.numberOfTicks = numberOfTicks;
+	}
+};
+/**
+* Position is still solvent and cannot be liquidated.
+* @see Errors.sol:84
+*/
+var NotMarginCalledError = class extends PanopticError {
+	name = "NotMarginCalledError";
+	constructor(cause) {
+		super("Position is still solvent and cannot be liquidated", cause);
+	}
+};
+/**
+* The user does not own enough assets to open/close a position.
+* @see Errors.sol:78
+*/
+var NotEnoughTokensError = class extends PanopticError {
+	name = "NotEnoughTokensError";
+	constructor(tokenAddress, assetsRequested, assetBalance, cause) {
+		super(`Not enough tokens: requested=${assetsRequested}, balance=${assetBalance}, token=${tokenAddress}`, cause);
+		this.tokenAddress = tokenAddress;
+		this.assetsRequested = assetsRequested;
+		this.assetBalance = assetBalance;
+	}
+};
+/**
+* There is not enough available liquidity in the chunk for a long leg.
+* @see Errors.sol:75
+*/
+var NotEnoughLiquidityInChunkError = class extends PanopticError {
+	name = "NotEnoughLiquidityInChunkError";
+	constructor(cause) {
+		super("Not enough liquidity in chunk for long leg creation or short leg closure", cause);
+	}
+};
+/**
+* There is not enough available liquidity to fulfill a credit.
+* @see Errors.sol:47
+*/
+var InsufficientCreditLiquidityError = class extends PanopticError {
+	name = "InsufficientCreditLiquidityError";
+	constructor(cause) {
+		super("Insufficient credit liquidity available in the PanopticPool", cause);
+	}
+};
+/**
+* The amount deposited is larger than the maximum permitted.
+* @see Errors.sol:25
+*/
+var DepositTooLargeError = class extends PanopticError {
+	name = "DepositTooLargeError";
+	constructor(cause) {
+		super("Deposit amount exceeds maximum permitted", cause);
+	}
+};
+/**
+* Attempted to withdraw/redeem less than a single asset.
+* @see Errors.sol:16
+*/
+var BelowMinimumRedemptionError = class extends PanopticError {
+	name = "BelowMinimumRedemptionError";
+	constructor(cause) {
+		super("Redemption amount below minimum threshold", cause);
+	}
+};
+/**
+* Attempted to withdraw/redeem more than available.
+* @see Errors.sol:35
+*/
+var ExceedsMaximumRedemptionError = class extends PanopticError {
+	name = "ExceedsMaximumRedemptionError";
+	constructor(cause) {
+		super("Redemption exceeds maximum available (liquidity, shares, or open positions)", cause);
+	}
+};
+/**
+* Mints/burns of a position returns no collateral requirement.
+* @see Errors.sol:141
+*/
+var ZeroCollateralRequirementError = class extends PanopticError {
+	name = "ZeroCollateralRequirementError";
+	constructor(cause) {
+		super("Position mint/burn returned zero collateral requirement", cause);
+	}
+};
+/**
+* The TokenId provided is malformed or invalid.
+* @see Errors.sol:54
+*/
+var InvalidTokenIdParameterError = class extends PanopticError {
+	name = "InvalidTokenIdParameterError";
+	/**
+	* Parameter type meanings:
+	* 0=poolId, 1=ratio, 2=tokenType, 3=riskPartner, 4=strike, 5=width, 6=duplicateChunk
+	*/
+	constructor(parameterType, cause) {
+		const paramNames = [
+			"poolId",
+			"ratio",
+			"tokenType",
+			"riskPartner",
+			"strike",
+			"width",
+			"duplicateChunk"
+		];
+		const paramName = paramNames[Number(parameterType)] ?? `unknown(${parameterType})`;
+		super(`Invalid TokenId parameter: ${paramName}`, cause);
+		this.parameterType = parameterType;
+	}
+};
+/**
+* Position is not owned by the user and has positionSize=0.
+* @see Errors.sol:96
+*/
+var PositionNotOwnedError = class extends PanopticError {
+	name = "PositionNotOwnedError";
+	constructor(cause) {
+		super("Position is not owned by the user", cause);
+	}
+};
+/**
+* The maximum token deltas for a position exceed limits.
+* @see Errors.sol:99
+*/
+var PositionTooLargeError = class extends PanopticError {
+	name = "PositionTooLargeError";
+	constructor(cause) {
+		super("Position size exceeds maximum allowed token deltas", cause);
+	}
+};
+/**
+* User has open positions, so they cannot transfer collateral shares.
+* @see Errors.sol:93
+*/
+var PositionCountNotZeroError = class extends PanopticError {
+	name = "PositionCountNotZeroError";
+	constructor(cause) {
+		super("Cannot transfer collateral shares while positions are open", cause);
+	}
+};
+/**
+* The list of provided TokenIds has a duplicate entry.
+* @see Errors.sol:28
+*/
+var DuplicateTokenIdError = class extends PanopticError {
+	name = "DuplicateTokenIdError";
+	constructor(cause) {
+		super("Duplicate TokenId in provided list", cause);
+	}
+};
+/**
+* The supplied tokenId has no valid legs.
+* @see Errors.sol:144
+*/
+var TokenIdHasZeroLegsError = class extends PanopticError {
+	name = "TokenIdHasZeroLegsError";
+	constructor(cause) {
+		super("TokenId has no valid legs", cause);
+	}
+};
+/**
+* Position would exceed maximum legs open for account.
+* @see Errors.sol:112
+*/
+var TooManyLegsOpenError = class extends PanopticError {
+	name = "TooManyLegsOpenError";
+	constructor(cause) {
+		super("Position would exceed maximum allowed legs open", cause);
+	}
+};
+/**
+* The provided list of option positions is incorrect or invalid.
+* @see Errors.sol:38
+*/
+var InputListFailError = class extends PanopticError {
+	name = "InputListFailError";
+	constructor(cause) {
+		super("Invalid position list provided", cause);
+	}
+};
+/**
+* Tick is not between MIN_TICK and MAX_TICK.
+* @see Errors.sol:41
+*/
+var InvalidTickError = class extends PanopticError {
+	name = "InvalidTickError";
+	constructor(cause) {
+		super("Tick is outside valid range (MIN_TICK to MAX_TICK)", cause);
+	}
+};
+/**
+* The tick range is invalid (not initializable or exceeds bounds).
+* @see Errors.sol:120
+*/
+var InvalidTickBoundError = class extends PanopticError {
+	name = "InvalidTickBoundError";
+	constructor(cause) {
+		super("Tick range is invalid (not initializable multiples of tickSpacing or exceeds bounds)", cause);
+	}
+};
+/**
+* The current tick has fallen outside the slippage range.
+* @see Errors.sol:102
+*/
+var PriceBoundFailError = class extends PanopticError {
+	name = "PriceBoundFailError";
+	constructor(currentTick, cause) {
+		super(`Price moved outside slippage bounds (currentTick=${currentTick})`, cause);
+		this.currentTick = currentTick;
+	}
+};
+/**
+* The price impact of the trade is too large.
+* @see Errors.sol:105
+*/
+var PriceImpactTooLargeError = class extends PanopticError {
+	name = "PriceImpactTooLargeError";
+	constructor(cause) {
+		super("Price impact of trade exceeds maximum allowed", cause);
+	}
+};
+/**
+* Mints/burns of zero-liquidity chunks are not supported.
+* @see Errors.sol:19
+*/
+var ChunkHasZeroLiquidityError = class extends PanopticError {
+	name = "ChunkHasZeroLiquidityError";
+	constructor(cause) {
+		super("Cannot mint/burn chunk with zero liquidity", cause);
+	}
+};
+/**
+* Liquidity in a chunk is above 2^128.
+* @see Errors.sol:44
+*/
+var LiquidityTooHighError = class extends PanopticError {
+	name = "LiquidityTooHighError";
+	constructor(cause) {
+		super("Liquidity exceeds maximum (2^128)", cause);
+	}
+};
+/**
+* Net liquidity is zero due to small positions.
+* @see Errors.sol:63
+*/
+var NetLiquidityZeroError = class extends PanopticError {
+	name = "NetLiquidityZeroError";
+	constructor(cause) {
+		super("Net liquidity is zero, cannot compute liquidity spread", cause);
+	}
+};
+/**
+* Effective liquidity above threshold during long mint or short burn.
+* @see Errors.sol:32
+*/
+var EffectiveLiquidityAboveThresholdError = class extends PanopticError {
+	name = "EffectiveLiquidityAboveThresholdError";
+	constructor(cause) {
+		super("Effective liquidity above spread threshold", cause);
+	}
+};
+/**
+* An oracle price is too far from another or the current tick.
+* @see Errors.sol:109
+*/
+var StaleOracleError = class extends PanopticError {
+	name = "StaleOracleError";
+	constructor(cause) {
+		super("Oracle price deviation too high (potential manipulation safeguard)", cause);
+	}
+};
+/**
+* None of the legs in a position are force-exercisable.
+* @see Errors.sol:66
+*/
+var NoLegsExercisableError = class extends PanopticError {
+	name = "NoLegsExercisableError";
+	constructor(cause) {
+		super("No legs are force-exercisable (all are short or ATM long)", cause);
+	}
+};
+/**
+* The leg is not long, so premium cannot be settled.
+* @see Errors.sol:69
+*/
+var NotALongLegError = class extends PanopticError {
+	name = "NotALongLegError";
+	constructor(cause) {
+		super("Cannot settle premium for non-long leg", cause);
+	}
+};
+/**
+* The Uniswap Pool has not been created.
+* @see Errors.sol:90
+*/
+var PoolNotInitializedError = class extends PanopticError {
+	name = "PoolNotInitializedError";
+	constructor(cause) {
+		super("Uniswap pool not initialized", cause);
+	}
+};
+/**
+* Smart contract has already been initialized.
+* @see Errors.sol:22
+*/
+var AlreadyInitializedError = class extends PanopticError {
+	name = "AlreadyInitializedError";
+	constructor(cause) {
+		super("Contract already initialized", cause);
+	}
+};
+/**
+* The supplied poolId does not match the poolId for that Uniswap Pool.
+* @see Errors.sol:132
+*/
+var WrongPoolIdError = class extends PanopticError {
+	name = "WrongPoolIdError";
+	constructor(cause) {
+		super("Pool ID mismatch", cause);
+	}
+};
+/**
+* The poolId's don't match (SFPM).
+* @see Errors.sol:135
+*/
+var WrongUniswapPoolError = class extends PanopticError {
+	name = "WrongUniswapPoolError";
+	constructor(cause) {
+		super("Uniswap pool mismatch", cause);
+	}
+};
+/**
+* The caller is not the Panoptic Pool.
+* @see Errors.sol:87
+*/
+var NotPanopticPoolError = class extends PanopticError {
+	name = "NotPanopticPoolError";
+	constructor(cause) {
+		super("Caller is not the Panoptic Pool", cause);
+	}
+};
+/**
+* Can only be called by the guardian.
+* @see Errors.sol:81
+*/
+var NotGuardianError = class extends PanopticError {
+	name = "NotGuardianError";
+	constructor(cause) {
+		super("Caller is not the guardian", cause);
+	}
+};
+/**
+* Can only be called by the Builder.
+* @see Errors.sol:72
+*/
+var NotBuilderError = class extends PanopticError {
+	name = "NotBuilderError";
+	constructor(cause) {
+		super("Caller is not the builder", cause);
+	}
+};
+/**
+* Invalid builder code.
+* @see Errors.sol:50
+*/
+var InvalidBuilderCodeError = class extends PanopticError {
+	name = "InvalidBuilderCodeError";
+	constructor(cause) {
+		super("Invalid builder code", cause);
+	}
+};
+/**
+* Mint or swap callback from invalid address.
+* @see Errors.sol:57
+*/
+var InvalidUniswapCallbackError = class extends PanopticError {
+	name = "InvalidUniswapCallbackError";
+	constructor(cause) {
+		super("Invalid Uniswap callback (address mismatch)", cause);
+	}
+};
+/**
+* Unlock callback from non-canonical pool manager.
+* @see Errors.sol:123
+*/
+var UnauthorizedUniswapCallbackError = class extends PanopticError {
+	name = "UnauthorizedUniswapCallbackError";
+	constructor(cause) {
+		super("Unauthorized Uniswap V4 callback", cause);
+	}
+};
+/**
+* ERC20 or SFPM (ERC1155) token transfer did not complete successfully.
+* @see Errors.sol:115
+*/
+var TransferFailedError = class extends PanopticError {
+	name = "TransferFailedError";
+	constructor(token, from, amount, balance, cause) {
+		super(`Transfer failed: token=${token}, from=${from}, amount=${amount}, balance=${balance}`, cause);
+		this.token = token;
+		this.from = from;
+		this.amount = amount;
+		this.balance = balance;
+	}
+};
+/**
+* Casting error (e.g., uint128(uint256(a)) fails).
+* @see Errors.sol:13
+*/
+var CastingError = class extends PanopticError {
+	name = "CastingError";
+	constructor(cause) {
+		super("Numeric casting overflow", cause);
+	}
+};
+/**
+* Underflow or overflow in library operation.
+* @see Errors.sol:126
+*/
+var UnderOverFlowError = class extends PanopticError {
+	name = "UnderOverFlowError";
+	constructor(cause) {
+		super("Arithmetic underflow or overflow", cause);
+	}
+};
+/**
+* Reentrancy check triggered.
+* @see Errors.sol:129
+*/
+var ReentrancyError = class extends PanopticError {
+	name = "ReentrancyError";
+	constructor(cause) {
+		super("Reentrancy detected", cause);
+	}
+};
+/**
+* Pool deployment via CREATE2 failed.
+*/
+var CreateFailError = class extends PanopticError {
+	name = "CreateFailError";
+	constructor(cause) {
+		super("Pool deployment failed (CREATE2)", cause);
+	}
+};
+/**
+* Zero address was supplied as a parameter.
+* @see Errors.sol:138
+*/
+var ZeroAddressError = class extends PanopticError {
+	name = "ZeroAddressError";
+	constructor(cause) {
+		super("Zero address supplied", cause);
+	}
+};
+/**
+* Length mismatch between positionIdList and positionBalanceArray.
+* @see Errors.sol:60
+*/
+var LengthMismatchError = class extends PanopticError {
+	name = "LengthMismatchError";
+	constructor(cause) {
+		super("Array length mismatch", cause);
+	}
+};
+
 //#endregion
 //#region src/generated.ts
 const collateralTrackerV2Abi = [
@@ -3606,6 +4083,241 @@ const combinedAbi = [
 	...riskEngineAbi,
 	...panopticErrorsAbi
 ];
+/**
+* Map of error names to error constructors.
+*/
+const errorConstructors = {
+	AccountInsolvent: (args, cause) => new AccountInsolventError(args[0], args[1], cause),
+	NotMarginCalled: (_args, cause) => new NotMarginCalledError(cause),
+	CreateFail: (_args, cause) => new CreateFailError(cause),
+	NotEnoughTokens: (args, cause) => new NotEnoughTokensError(args[0], args[1], args[2], cause),
+	NotEnoughLiquidityInChunk: (_args, cause) => new NotEnoughLiquidityInChunkError(cause),
+	InsufficientCreditLiquidity: (_args, cause) => new InsufficientCreditLiquidityError(cause),
+	DepositTooLarge: (_args, cause) => new DepositTooLargeError(cause),
+	BelowMinimumRedemption: (_args, cause) => new BelowMinimumRedemptionError(cause),
+	ExceedsMaximumRedemption: (_args, cause) => new ExceedsMaximumRedemptionError(cause),
+	ZeroCollateralRequirement: (_args, cause) => new ZeroCollateralRequirementError(cause),
+	InvalidTokenIdParameter: (args, cause) => new InvalidTokenIdParameterError(args[0], cause),
+	PositionNotOwned: (_args, cause) => new PositionNotOwnedError(cause),
+	PositionTooLarge: (_args, cause) => new PositionTooLargeError(cause),
+	PositionCountNotZero: (_args, cause) => new PositionCountNotZeroError(cause),
+	DuplicateTokenId: (_args, cause) => new DuplicateTokenIdError(cause),
+	TokenIdHasZeroLegs: (_args, cause) => new TokenIdHasZeroLegsError(cause),
+	TooManyLegsOpen: (_args, cause) => new TooManyLegsOpenError(cause),
+	InputListFail: (_args, cause) => new InputListFailError(cause),
+	InvalidTick: (_args, cause) => new InvalidTickError(cause),
+	InvalidTickBound: (_args, cause) => new InvalidTickBoundError(cause),
+	PriceBoundFail: (args, cause) => new PriceBoundFailError(args[0], cause),
+	PriceImpactTooLarge: (_args, cause) => new PriceImpactTooLargeError(cause),
+	ChunkHasZeroLiquidity: (_args, cause) => new ChunkHasZeroLiquidityError(cause),
+	LiquidityTooHigh: (_args, cause) => new LiquidityTooHighError(cause),
+	NetLiquidityZero: (_args, cause) => new NetLiquidityZeroError(cause),
+	EffectiveLiquidityAboveThreshold: (_args, cause) => new EffectiveLiquidityAboveThresholdError(cause),
+	StaleOracle: (_args, cause) => new StaleOracleError(cause),
+	NoLegsExercisable: (_args, cause) => new NoLegsExercisableError(cause),
+	NotALongLeg: (_args, cause) => new NotALongLegError(cause),
+	PoolNotInitialized: (_args, cause) => new PoolNotInitializedError(cause),
+	AlreadyInitialized: (_args, cause) => new AlreadyInitializedError(cause),
+	WrongPoolId: (_args, cause) => new WrongPoolIdError(cause),
+	WrongUniswapPool: (_args, cause) => new WrongUniswapPoolError(cause),
+	NotPanopticPool: (_args, cause) => new NotPanopticPoolError(cause),
+	NotGuardian: (_args, cause) => new NotGuardianError(cause),
+	NotBuilder: (_args, cause) => new NotBuilderError(cause),
+	InvalidBuilderCode: (_args, cause) => new InvalidBuilderCodeError(cause),
+	InvalidUniswapCallback: (_args, cause) => new InvalidUniswapCallbackError(cause),
+	UnauthorizedUniswapCallback: (_args, cause) => new UnauthorizedUniswapCallbackError(cause),
+	TransferFailed: (args, cause) => new TransferFailedError(args[0], args[1], args[2], args[3], cause),
+	CastingError: (_args, cause) => new CastingError(cause),
+	UnderOverFlow: (_args, cause) => new UnderOverFlowError(cause),
+	Reentrancy: (_args, cause) => new ReentrancyError(cause),
+	ZeroAddress: (_args, cause) => new ZeroAddressError(cause),
+	LengthMismatch: (_args, cause) => new LengthMismatchError(cause)
+};
+/**
+* Parse a raw contract error into a typed SDK error.
+*
+* This function attempts to decode the error data from a failed contract call
+* and return a typed error instance with extracted parameters.
+*
+* @param error - The raw error from a failed contract call
+* @returns Parsed error with typed error instance, or null if parsing fails
+*
+* @example
+* ```typescript
+* try {
+*   await contract.openPosition(...)
+* } catch (rawError) {
+*   const parsed = parsePanopticError(rawError)
+*   if (parsed) {
+*     console.log('Error:', parsed.errorName)
+*     if (parsed.error instanceof AccountInsolventError) {
+*       console.log('Solvent value:', parsed.error.solvent)
+*     }
+*   }
+* }
+* ```
+*/
+function parsePanopticError(error) {
+	const viemDecoded = extractViemDecodedError(error);
+	if (viemDecoded) return buildParsedError(viemDecoded.errorName, viemDecoded.args, error);
+	const errorData = extractErrorData(error);
+	if (!errorData) return null;
+	try {
+		const decoded = decodeErrorResult({
+			abi: combinedAbi,
+			data: errorData
+		});
+		return buildParsedError(decoded.errorName, decoded.args ?? [], error);
+	} catch {
+		if (errorData.length >= 10) {
+			const selector = errorData.slice(0, 10);
+			const match = matchSelectorToErrorName(selector);
+			if (match) return buildParsedError(match, [], error);
+		}
+		return null;
+	}
+}
+/**
+* Walk the cause chain looking for a viem ContractFunctionRevertedError
+* that already has decoded `.data` (an object with `errorName` and `args`).
+* This happens when the ABI passed to simulateContract includes the error definitions.
+*/
+function extractViemDecodedError(error) {
+	if (!error || typeof error !== "object") return null;
+	if (error instanceof BaseError) {
+		let found = null;
+		error.walk((e) => {
+			if (found) return false;
+			const node = e;
+			if (node.data && typeof node.data === "object" && "errorName" in node.data && typeof node.data.errorName === "string") {
+				const data = node.data;
+				found = {
+					errorName: data.errorName,
+					args: data.args ?? []
+				};
+				return true;
+			}
+			return false;
+		});
+		return found;
+	}
+	let current = error;
+	for (let i = 0; i < 10 && current; i++) {
+		if (current.data && typeof current.data === "object" && "errorName" in current.data && typeof current.data.errorName === "string") {
+			const data = current.data;
+			return {
+				errorName: data.errorName,
+				args: data.args ?? []
+			};
+		}
+		current = current.cause && typeof current.cause === "object" ? current.cause : null;
+	}
+	return null;
+}
+/**
+* Build a ParsedError from a decoded error name and args.
+*/
+function buildParsedError(errorName, args, originalError) {
+	const constructor = errorConstructors[errorName];
+	const cause = originalError instanceof Error ? originalError : void 0;
+	if (!constructor) {
+		const unknownError = new PanopticError(`Unknown contract error: ${errorName}`);
+		unknownError.errorName = errorName;
+		return {
+			error: unknownError,
+			errorName,
+			args
+		};
+	}
+	const typedError = constructor(args, cause);
+	typedError.errorName = errorName;
+	return {
+		error: typedError,
+		errorName,
+		args
+	};
+}
+/**
+* Match a 4-byte selector against the panoptic errors ABI.
+* Used as fallback when we only have the selector (no encoded args).
+*/
+function matchSelectorToErrorName(selector) {
+	for (const item of panopticErrorsAbi) {
+		if (item.type !== "error") continue;
+		const computed = toFunctionSelector(`${item.name}(${item.inputs.map((i) => i.type).join(",")})`);
+		if (computed === selector) return item.name;
+	}
+	return null;
+}
+/**
+* Extract error data from various error formats.
+*
+* Strategy:
+* 1. Use viem's BaseError.walk() to traverse the full cause chain and find
+*    hex data on any node (handles arbitrary nesting depth for multicall etc.)
+* 2. Fall back to manual cause-chain walk for non-viem errors
+* 3. Last resort: extract selector from error message (loses args)
+*/
+function extractErrorData(error) {
+	if (!error) return null;
+	if (typeof error === "string" && error.startsWith("0x")) return error;
+	if (typeof error !== "object") return null;
+	if (error instanceof BaseError) {
+		let foundData = null;
+		error.walk((e) => {
+			if (foundData) return false;
+			const node = e;
+			if (typeof node.raw === "string" && node.raw.startsWith("0x") && node.raw.length > 10) {
+				foundData = node.raw;
+				return true;
+			}
+			if (node.data && typeof node.data === "string" && node.data.startsWith("0x")) {
+				foundData = node.data;
+				return true;
+			}
+			if (node.data && typeof node.data === "object") {
+				const nested = node.data;
+				if (nested.data && typeof nested.data === "string" && nested.data.startsWith("0x")) {
+					foundData = nested.data;
+					return true;
+				}
+			}
+			return false;
+		});
+		if (foundData) return foundData;
+		error.walk((e) => {
+			if (foundData) return false;
+			const node = e;
+			if (node.signature && typeof node.signature === "string" && node.signature.startsWith("0x")) {
+				foundData = node.signature;
+				return true;
+			}
+			return false;
+		});
+		if (foundData) return foundData;
+	}
+	let current = error;
+	const maxDepth = 10;
+	for (let i = 0; i < maxDepth && current; i++) {
+		if (typeof current.raw === "string" && current.raw.startsWith("0x") && current.raw.length > 10) return current.raw;
+		if (current.data && typeof current.data === "string" && current.data.startsWith("0x")) return current.data;
+		if (current.data && typeof current.data === "object") {
+			const nested = current.data;
+			if (nested.data && typeof nested.data === "string" && nested.data.startsWith("0x")) return nested.data;
+		}
+		if (current.error && typeof current.error === "object") {
+			const rpcError = current.error;
+			if (rpcError.data && typeof rpcError.data === "string" && rpcError.data.startsWith("0x")) return rpcError.data;
+		}
+		current = current.cause && typeof current.cause === "object" ? current.cause : null;
+	}
+	const obj = error;
+	if (obj.message && typeof obj.message === "string") {
+		const signatureMatch = obj.message.match(/signature:?\s*["']?(0x[a-fA-F0-9]{8,})/i);
+		if (signatureMatch) return signatureMatch[1];
+	}
+	return null;
+}
 
 //#endregion
 //#region src/panoptic/v2/tokenId/constants.ts
@@ -5625,6 +6337,17 @@ function createTxResult(client, hash) {
 * @returns TxResult
 */
 async function submitWrite(params) {
+	try {
+		return await submitWriteRequest({
+			...params,
+			abi: [...params.abi, ...panopticErrorsAbi]
+		});
+	} catch (error) {
+		if (error instanceof PanopticError) throw error;
+		throw parsePanopticError(error)?.error ?? error;
+	}
+}
+async function submitWriteRequest(params) {
 	const { client, walletClient, account, address, abi, functionName, args, value, txOverrides } = params;
 	const broadcaster = txOverrides?.broadcaster;
 	if (broadcaster) {