@panoptic-eng/sdk 1.0.37 → 1.0.39

package/dist/{router-DcoU2KmV.js → router-BTfbaRfg.js}

@@ -1,4 +1,4 @@
-import { PanopticError } from "./position-C8rkkKhi.js";
+import { PanopticError } from "./getTrackedPositionIds-ms3W9dYB.js";
 import { BaseError, ContractFunctionRevertedError, encodeAbiParameters, encodeFunctionData, encodePacked, zeroAddress } from "viem";
 
 //#region src/uniswap/v4/router/errors.ts
@@ -309,5 +309,4 @@ function isRevert(err) {
 }
 
 //#endregion
-export { AmountExceedsUint128Error, InvalidSwapTokenError, MSG_SENDER, MissingSweepRecipientError, QuoterUnavailableError, UNISWAP_V3_ADDRESSES, UnsupportedChainError, V3_SWAP_EXACT_IN, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, encodeV3Path, getUniswapV3Addresses, quoteV3ExactIn, universalRouterAbi };
-//# sourceMappingURL=router-DcoU2KmV.js.map
+export { AmountExceedsUint128Error, InvalidSwapTokenError, MSG_SENDER, MissingSweepRecipientError, QuoterUnavailableError, UNISWAP_V3_ADDRESSES, UnsupportedChainError, V3_SWAP_EXACT_IN, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, encodeV3Path, getUniswapV3Addresses, quoteV3ExactIn, universalRouterAbi };

package/dist/{router-CS86ptMu.js → router-mLWy0MD9.js}

@@ -1,5 +1,5 @@
-import { PanopticError, getBlockMeta$1 as getBlockMeta, getPool, submitWrite } from "./position-C8rkkKhi.js";
-import { AmountExceedsUint128Error, InvalidSwapTokenError, MissingSweepRecipientError, QuoterUnavailableError, UnsupportedChainError, universalRouterAbi } from "./router-DcoU2KmV.js";
+import { PanopticError, getBlockMeta, getPool, submitWrite } from "./getTrackedPositionIds-ms3W9dYB.js";
+import { AmountExceedsUint128Error, InvalidSwapTokenError, MissingSweepRecipientError, QuoterUnavailableError, UnsupportedChainError, universalRouterAbi } from "./router-BTfbaRfg.js";
 import { BaseError, ContractFunctionRevertedError, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, isAddressEqual, maxUint256, zeroAddress } from "viem";
 
 //#region src/uniswap/v4/addresses.ts
@@ -977,5 +977,4 @@ async function swapExactOutViaRouterAndWait(params) {
 }
 
 //#endregion
-export { PERMIT2_ADDRESS, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, TAKE_ALL, UNISWAP_V4_ADDRESSES, V4_SWAP, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, quoteV4ExactInByPoolKey, resolveSwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactOutViaRouter, swapExactOutViaRouterAndWait };
-//# sourceMappingURL=router-CS86ptMu.js.map
+export { PERMIT2_ADDRESS, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, TAKE_ALL, UNISWAP_V4_ADDRESSES, V4_SWAP, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, quoteV4ExactInByPoolKey, resolveSwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactOutViaRouter, swapExactOutViaRouterAndWait };

package/dist/test/index.d.ts

@@ -1,7 +1,7 @@
-import { Address } from "viem";
 import { ReactNode } from "react";
 import { Config } from "wagmi";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { Address } from "viem";
 
 //#region src/test/test-utils.d.ts
 declare const spawnAnvil: (args?: AnvilArgs) => Promise<void>;

package/dist/test/index.js

@@ -1,7 +1,7 @@
-import { useEffect } from "react";
-import { WagmiProvider, useConnect } from "wagmi";
 import { exec, execSync, spawn } from "node:child_process";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { useEffect } from "react";
+import { WagmiProvider, useConnect } from "wagmi";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/test/test-utils.ts

package/dist/transactionFees-C_Qx07mx.js

@@ -0,0 +1,174 @@
+import { estimateFeesPerGas, getFeeHistory } from "viem/actions";
+
+//#region src/hypoVault/transactionFees.ts
+const MIN_VAULT_PRIORITY_FEE_PER_GAS = 100000000n;
+const MAX_VAULT_PRIORITY_FEE_PER_GAS = 3000000000n;
+const MAX_VAULT_TRANSACTION_GAS_COST = 15000000000000000n;
+const FEE_HISTORY_BLOCK_COUNT = 20;
+const FEE_HISTORY_REWARD_PERCENTILES = [90];
+const BASE_FEE_BUFFER_NUMERATOR = 1125n;
+const BASE_FEE_BUFFER_DENOMINATOR = 1000n;
+const GAS_ESTIMATE_BUFFER_NUMERATOR = 3n;
+const GAS_ESTIMATE_BUFFER_DENOMINATOR = 2n;
+var VaultTransactionFeeEstimationError = class extends Error {
+	feeHistoryError;
+	fallbackError;
+	constructor({ feeHistoryError, fallbackError }) {
+		super("Unable to estimate EIP-1559 fees for vault transaction");
+		this.name = "VaultTransactionFeeEstimationError";
+		this.feeHistoryError = feeHistoryError;
+		this.fallbackError = fallbackError;
+	}
+};
+var VaultTransactionGasCostLimitError = class extends Error {
+	gasLimit;
+	maximumAffordableFeePerGas;
+	minimumRequiredFeePerGas;
+	constructor({ gasLimit, maximumAffordableFeePerGas, minimumRequiredFeePerGas }) {
+		super(`Vault transaction cannot fit the ${MAX_VAULT_TRANSACTION_GAS_COST.toString()} wei gas-cost limit: gasLimit=${gasLimit.toString()}, maximumAffordableFeePerGas=${maximumAffordableFeePerGas.toString()}, minimumRequiredFeePerGas=${minimumRequiredFeePerGas.toString()}`);
+		this.name = "VaultTransactionGasCostLimitError";
+		this.gasLimit = gasLimit;
+		this.maximumAffordableFeePerGas = maximumAffordableFeePerGas;
+		this.minimumRequiredFeePerGas = minimumRequiredFeePerGas;
+	}
+};
+function ceilMultiplyFraction(value, numerator, denominator) {
+	return (value * numerator + denominator - 1n) / denominator;
+}
+function medianBigInt(values) {
+	if (values.length === 0) return void 0;
+	const sorted = [...values].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+	const upperMiddleIndex = Math.floor(sorted.length / 2);
+	const upperMiddle = sorted[upperMiddleIndex];
+	if (upperMiddle === void 0) return void 0;
+	if (sorted.length % 2 === 1) return upperMiddle;
+	const lowerMiddle = sorted[upperMiddleIndex - 1];
+	return lowerMiddle === void 0 ? void 0 : (lowerMiddle + upperMiddle) / 2n;
+}
+function clampPriorityFee(priorityFee) {
+	if (priorityFee < MIN_VAULT_PRIORITY_FEE_PER_GAS) return MIN_VAULT_PRIORITY_FEE_PER_GAS;
+	if (priorityFee > MAX_VAULT_PRIORITY_FEE_PER_GAS) return MAX_VAULT_PRIORITY_FEE_PER_GAS;
+	return priorityFee;
+}
+function resolveFeeHistoryQuote({ baseFeePerGas, reward }) {
+	const latestBaseFeeIndex = baseFeePerGas.length - 2;
+	if (latestBaseFeeIndex < 0 || reward === void 0 || reward.length === 0) return null;
+	const p90Rewards = reward.flatMap((blockRewards) => {
+		const p90 = blockRewards[0];
+		return p90 === void 0 ? [] : [p90];
+	});
+	const sampledPriorityFee = medianBigInt(p90Rewards);
+	if (sampledPriorityFee === void 0) return null;
+	const maxPriorityFeePerGas = clampPriorityFee(sampledPriorityFee);
+	const bufferedBaseFee = ceilMultiplyFraction(baseFeePerGas[latestBaseFeeIndex], BASE_FEE_BUFFER_NUMERATOR, BASE_FEE_BUFFER_DENOMINATOR);
+	return {
+		maxFeePerGas: bufferedBaseFee + maxPriorityFeePerGas,
+		maxPriorityFeePerGas,
+		minimumMaxFeePerGas: bufferedBaseFee + MIN_VAULT_PRIORITY_FEE_PER_GAS,
+		source: "fee_history"
+	};
+}
+function resolveFallbackQuote({ maxFeePerGas: estimatedMaxFeePerGas, maxPriorityFeePerGas: estimatedPriorityFeePerGas }) {
+	const maxPriorityFeePerGas = clampPriorityFee(estimatedPriorityFeePerGas);
+	const estimatedBaseFeeAllowance = estimatedMaxFeePerGas > estimatedPriorityFeePerGas ? estimatedMaxFeePerGas - estimatedPriorityFeePerGas : 0n;
+	return {
+		maxFeePerGas: estimatedBaseFeeAllowance + maxPriorityFeePerGas,
+		maxPriorityFeePerGas,
+		minimumMaxFeePerGas: estimatedBaseFeeAllowance + MIN_VAULT_PRIORITY_FEE_PER_GAS,
+		source: "viem_fallback"
+	};
+}
+function applyVaultTransactionGasCostLimit(quote, gasLimit) {
+	if (gasLimit <= 0n) throw new Error(`Vault transaction gas limit must be positive, received ${gasLimit.toString()}`);
+	const maximumAffordableFeePerGas = MAX_VAULT_TRANSACTION_GAS_COST / gasLimit;
+	if (maximumAffordableFeePerGas < quote.minimumMaxFeePerGas) throw new VaultTransactionGasCostLimitError({
+		gasLimit,
+		maximumAffordableFeePerGas,
+		minimumRequiredFeePerGas: quote.minimumMaxFeePerGas
+	});
+	if (quote.maxFeePerGas <= maximumAffordableFeePerGas) return quote;
+	const bufferedBaseFee = quote.minimumMaxFeePerGas - MIN_VAULT_PRIORITY_FEE_PER_GAS;
+	const affordablePriorityFee = maximumAffordableFeePerGas - bufferedBaseFee;
+	return {
+		...quote,
+		maxFeePerGas: maximumAffordableFeePerGas,
+		maxPriorityFeePerGas: quote.maxPriorityFeePerGas < affordablePriorityFee ? quote.maxPriorityFeePerGas : affordablePriorityFee
+	};
+}
+function bufferVaultTransactionGasEstimate(gasEstimate) {
+	if (gasEstimate <= 0n) throw new Error(`Vault transaction gas estimate must be positive, received ${gasEstimate.toString()}`);
+	return ceilMultiplyFraction(gasEstimate, GAS_ESTIMATE_BUFFER_NUMERATOR, GAS_ESTIMATE_BUFFER_DENOMINATOR);
+}
+function validateVaultSignedTransactionFeeCaps(feeCaps, quote) {
+	const { gasLimit, maxFeePerGas, maxPriorityFeePerGas } = feeCaps;
+	if (maxFeePerGas === null || maxPriorityFeePerGas === null) return {
+		valid: false,
+		code: "MissingEip1559Fees",
+		reason: "Signed transaction must include EIP-1559 max fee and priority fee caps."
+	};
+	if (maxPriorityFeePerGas > maxFeePerGas) return {
+		valid: false,
+		code: "InvalidFeeCaps",
+		reason: `Signed transaction maxPriorityFeePerGas (${maxPriorityFeePerGas.toString()} wei) cannot exceed maxFeePerGas (${maxFeePerGas.toString()} wei).`
+	};
+	if (maxPriorityFeePerGas < MIN_VAULT_PRIORITY_FEE_PER_GAS) return {
+		valid: false,
+		code: "PriorityFeeTooLow",
+		reason: `Signed transaction maxPriorityFeePerGas (${maxPriorityFeePerGas.toString()} wei) must be at least ${MIN_VAULT_PRIORITY_FEE_PER_GAS.toString()} wei (0.1 gwei).`
+	};
+	if (maxPriorityFeePerGas > MAX_VAULT_PRIORITY_FEE_PER_GAS) return {
+		valid: false,
+		code: "PriorityFeeTooHigh",
+		reason: `Signed transaction maxPriorityFeePerGas (${maxPriorityFeePerGas.toString()} wei) must not exceed ${MAX_VAULT_PRIORITY_FEE_PER_GAS.toString()} wei (3 gwei).`
+	};
+	if (gasLimit !== void 0 && gasLimit !== null && gasLimit * maxFeePerGas > MAX_VAULT_TRANSACTION_GAS_COST) return {
+		valid: false,
+		code: "GasCostTooHigh",
+		reason: `Signed transaction maximum gas cost (${(gasLimit * maxFeePerGas).toString()} wei) must not exceed ${MAX_VAULT_TRANSACTION_GAS_COST.toString()} wei (0.015 ETH).`
+	};
+	if (quote !== void 0 && maxFeePerGas < quote.minimumMaxFeePerGas) return {
+		valid: false,
+		code: "MaxFeeTooLow",
+		reason: `Signed transaction maxFeePerGas (${maxFeePerGas.toString()} wei) must be at least ${quote.minimumMaxFeePerGas.toString()} wei for the buffered next-block base fee and 0.1 gwei minimum priority fee.`
+	};
+	return { valid: true };
+}
+async function resolveVaultTransactionFeeQuote({ readFeeHistory, readFallbackEstimate }) {
+	let feeHistoryError;
+	try {
+		const quote = resolveFeeHistoryQuote(await readFeeHistory());
+		if (quote !== null) return quote;
+		feeHistoryError = new Error("eth_feeHistory returned incomplete base fee or reward data");
+	} catch (error) {
+		feeHistoryError = error;
+	}
+	try {
+		return resolveFallbackQuote(await readFallbackEstimate());
+	} catch (fallbackError) {
+		throw new VaultTransactionFeeEstimationError({
+			feeHistoryError,
+			fallbackError
+		});
+	}
+}
+/**
+* Resolve explicit EIP-1559 fees for operator-controlled vault transactions.
+*
+* The normal path follows the median p90 priority fee from the last 20 blocks,
+* with a 0.1 gwei floor and 3 gwei ceiling. If fee history is unavailable,
+* Viem's estimate is used while preserving those bounds and its original
+* base-fee allowance.
+*/
+async function getVaultTransactionFeeQuote(client) {
+	return resolveVaultTransactionFeeQuote({
+		readFeeHistory: () => getFeeHistory(client, {
+			blockCount: FEE_HISTORY_BLOCK_COUNT,
+			blockTag: "latest",
+			rewardPercentiles: FEE_HISTORY_REWARD_PERCENTILES
+		}),
+		readFallbackEstimate: () => estimateFeesPerGas(client)
+	});
+}
+
+//#endregion
+export { MAX_VAULT_PRIORITY_FEE_PER_GAS, MAX_VAULT_TRANSACTION_GAS_COST, MIN_VAULT_PRIORITY_FEE_PER_GAS, VaultTransactionFeeEstimationError, VaultTransactionGasCostLimitError, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, getVaultTransactionFeeQuote, validateVaultSignedTransactionFeeCaps };