@panoptic-eng/sdk 1.0.60 → 1.0.62

package/dist/index.js

@@ -24608,15 +24608,29 @@ var _4663 = {
 	"panoptic": {
 		"pool": {
 			"version": "v4",
-			"panopticPool": "0x00000000989bcb6f24af4a1Ab2A6d6a31c98A58E",
-			"collateralTracker0": "0x49eaAC32A7CD4B8fB2209a12859a95E0b20aB0e5",
-			"collateralTracker1": "0x670C44a0FC35dbC410498e47A6290a1C3196d191"
+			"panopticPool": "0x000000000c21b38c54AcA7c7145Df01ff09d69Bb",
+			"collateralTracker0": "0xDc508622CD7e3850c8240e88c10361Cf493465b6",
+			"collateralTracker1": "0x9212d804953bAf89C24ceFa6545aA293bA08a876"
+		},
+		"additionalPools": {
+			"spyUsdg30bpsV4": {
+				"version": "v4",
+				"panopticPool": "0x00000000989bcb6f24af4a1Ab2A6d6a31c98A58E",
+				"collateralTracker0": "0x49eaAC32A7CD4B8fB2209a12859a95E0b20aB0e5",
+				"collateralTracker1": "0x670C44a0FC35dbC410498e47A6290a1C3196d191"
+			},
+			"spyUsdg5bpsV4": {
+				"version": "v4",
+				"panopticPool": "0x000000000c21b38c54AcA7c7145Df01ff09d69Bb",
+				"collateralTracker0": "0xDc508622CD7e3850c8240e88c10361Cf493465b6",
+				"collateralTracker1": "0x9212d804953bAf89C24ceFa6545aA293bA08a876"
+			}
 		},
 		"v2": {
 			"semiFungiblePositionManagerV4": "0x00000000000005C3287f136Ef5AF56c68Ea6849f",
 			"semiFungiblePositionManagerV3": "0x00000000000005E4693aDc8Ec0f12D686f728198",
 			"builderFactory": "0x0000000000000a3D22E158417AA639D7F71b0FF7",
-			"riskEngine": "0x000000000000075e29cdaa9cb640a69e148ca7da",
+			"riskEngine": "0x0000000000000fE1E261f66ce2F44def4F5Ae0CB",
 			"panopticPoolImplementation": "0x000000000000135429F0DaCaB61639Bf6a63EbbC",
 			"collateralTrackerImplementation": "0x0000000000001d9c38CA405A2e04420865A08A33",
 			"panopticFactoryV4": "0x0000000000000c51d0f8cf4bd9adE7191372a625",
@@ -24632,13 +24646,29 @@ var _4663 = {
 		"0x0000000000000fe1e261f66ce2f44def4f5ae0cb",
 		"0x0000000000000f3fb82469581A74776178E76Ca4"
 	],
-	"markets": { "spyUsdg": {
-		"currency0": "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
-		"currency1": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
-		"fee": 3e3,
-		"tickSpacing": 60,
-		"poolId": "0xfe2a80bb5618fd14984b92ca6d45bf5ba67443ddb1435e28b2e48df2fc1526cd"
-	} },
+	"markets": {
+		"spyUsdg": {
+			"currency0": "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
+			"currency1": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+			"fee": 500,
+			"tickSpacing": 5,
+			"poolId": "0xe5923c8a8be481ec89a2ca784a2bbfa4235de6d88f92260fd66b660c4babf907"
+		},
+		"spyUsdg30bps": {
+			"currency0": "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
+			"currency1": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+			"fee": 3e3,
+			"tickSpacing": 60,
+			"poolId": "0xfe2a80bb5618fd14984b92ca6d45bf5ba67443ddb1435e28b2e48df2fc1526cd"
+		},
+		"spyUsdg5bps": {
+			"currency0": "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
+			"currency1": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+			"fee": 500,
+			"tickSpacing": 5,
+			"poolId": "0xe5923c8a8be481ec89a2ca784a2bbfa4235de6d88f92260fd66b660c4babf907"
+		}
+	},
 	"subgraphs": {
 		"hypovault": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/hypovault-subgraph-robinhood/prod/gn",
 		"panoptic": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/panoptic-subgraph-robinhood/v2_prod/gn"
@@ -24789,23 +24819,27 @@ function getChainDeployment(chainId) {
 	return CHAIN_DEPLOYMENTS[chainId];
 }
 function requireChainDeployment(chainId) {
-	const deployment$2 = getChainDeployment(chainId);
-	if (deployment$2 === void 0) throw new Error(`Unsupported chain deployment for chainId ${chainId}`);
-	return deployment$2;
+	const deployment$3 = getChainDeployment(chainId);
+	if (deployment$3 === void 0) throw new Error(`Unsupported chain deployment for chainId ${chainId}`);
+	return deployment$3;
 }
 function isSupportedChain(chainId) {
 	return getChainDeployment(chainId) !== void 0;
 }
-function getEthUsdcMarket(deployment$2) {
-	const market = deployment$2.markets.ethUsdc5bps ?? deployment$2.markets.ethUsdc30bps;
-	if (market === void 0) throw new Error(`Missing ETH/USDC market for chainId ${deployment$2.chainId}`);
+function getEthUsdcMarket(deployment$3) {
+	const market = deployment$3.markets.ethUsdc5bps ?? deployment$3.markets.ethUsdc30bps;
+	if (market === void 0) throw new Error(`Missing ETH/USDC market for chainId ${deployment$3.chainId}`);
 	return market;
 }
-function getSpyUsdgMarket(deployment$2) {
-	const market = deployment$2.markets.spyUsdg;
-	if (market === void 0) throw new Error(`Missing SPY/USDG market for chainId ${deployment$2.chainId}`);
+function getSpyUsdgMarket(deployment$3) {
+	const market = deployment$3.markets.spyUsdg;
+	if (market === void 0) throw new Error(`Missing SPY/USDG market for chainId ${deployment$3.chainId}`);
 	return market;
 }
+function requireDeploymentValue(value, label) {
+	if (value === void 0) throw new Error(`Missing deployment value: ${label}`);
+	return value;
+}
 const MAINNET_DEPLOYMENT = CHAIN_DEPLOYMENTS[MAINNET_CHAIN_ID];
 const MAINNET_ETH_USDC_5BPS_V3_PANOPTIC_POOL_ADDRESSES = MAINNET_DEPLOYMENT.panoptic.additionalPools?.ethUsdc5bpsV3;
 const MAINNET_PANOPTIC_V2_ADDRESSES = MAINNET_DEPLOYMENT.panoptic.v2;
@@ -24834,9 +24868,13 @@ const ROBINHOOD_HYPOVAULT_ADDRESSES = ROBINHOOD_DEPLOYMENT.hypovault.vaults;
 const ROBINHOOD_HYPOVAULT_MANAGER_ADDRESSES = ROBINHOOD_DEPLOYMENT.hypovault.managers;
 const ROBINHOOD_HYPOVAULT_MANAGER_TURNKEY_SIGNERS = ROBINHOOD_DEPLOYMENT.hypovault.turnkeySigners;
 const ROBINHOOD_PANOPTIC_POOL_ADDRESSES = ROBINHOOD_DEPLOYMENT.panoptic.pool;
+const ROBINHOOD_SPY_USDG_30BPS_PANOPTIC_POOL_ADDRESSES = requireDeploymentValue(ROBINHOOD_DEPLOYMENT.panoptic.additionalPools?.spyUsdg30bpsV4, "Robinhood SPY/USDG 30bps Panoptic pool");
+const ROBINHOOD_SPY_USDG_5BPS_PANOPTIC_POOL_ADDRESSES = requireDeploymentValue(ROBINHOOD_DEPLOYMENT.panoptic.additionalPools?.spyUsdg5bpsV4, "Robinhood SPY/USDG 5bps Panoptic pool");
 const ROBINHOOD_PANOPTIC_V2_ADDRESSES = ROBINHOOD_DEPLOYMENT.panoptic.v2;
 const ROBINHOOD_RISK_ENGINES = ROBINHOOD_DEPLOYMENT.riskEngines;
 const ROBINHOOD_SPY_USDG_MARKET = getSpyUsdgMarket(ROBINHOOD_DEPLOYMENT);
+const ROBINHOOD_SPY_USDG_30BPS_MARKET = requireDeploymentValue(ROBINHOOD_DEPLOYMENT.markets.spyUsdg30bps, "Robinhood SPY/USDG 30bps market");
+const ROBINHOOD_SPY_USDG_5BPS_MARKET = requireDeploymentValue(ROBINHOOD_DEPLOYMENT.markets.spyUsdg5bps, "Robinhood SPY/USDG 5bps market");
 
 //#endregion
 //#region ../deployments/src/vaultDisplayNames.js
@@ -24887,8 +24925,8 @@ const VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN = {
 	},
 	[ROBINHOOD_CHAIN_ID]: { [robinhoodUsdgVault.toLowerCase()]: () => "0DTE +67∆ Vault" }
 };
-function resolveVaultDisplayName({ chainId, vaultAddress: vaultAddress$1, underlyingSymbol, fallbackName }) {
-	const vaultAddressLower = vaultAddress$1.toLowerCase();
+function resolveVaultDisplayName({ chainId, vaultAddress: vaultAddress$3, underlyingSymbol, fallbackName }) {
+	const vaultAddressLower = vaultAddress$3.toLowerCase();
 	const resolver = VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN[chainId]?.[vaultAddressLower];
 	if (resolver !== void 0) return resolver({
 		chainId,
@@ -25078,7 +25116,6 @@ function createStrategistLeavesArtifact(metadata, definitions) {
 const SEPOLIA_DEPLOYMENT$5 = requireChainDeployment(SEPOLIA_CHAIN_ID);
 const BASE_DEPLOYMENT$2 = requireChainDeployment(BASE_CHAIN_ID);
 const MAINNET_DEPLOYMENT$6 = requireChainDeployment(MAINNET_CHAIN_ID);
-const ROBINHOOD_DEPLOYMENT$1 = requireChainDeployment(ROBINHOOD_CHAIN_ID);
 const MAX_PRICE_DEVIATION = 100;
 const WSPCXX_USDC_MAX_PRICE_DEVIATION = 1e4;
 const DEFAULT_TRIGGER_TICK = 150;
@@ -25121,14 +25158,24 @@ const MAINNET_WSPCXX_USDC_POOL_INFO = {
 	token1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
 	positionScanFromBlock: 25302077n
 };
-const ROBINHOOD_SPY_USDG_POOL_DEPLOYMENT_BLOCK = 62901925n;
-const ROBINHOOD_SPY_USDG_POOL_INFO = {
+const ROBINHOOD_SPY_USDG_30BPS_POOL_DEPLOYMENT_BLOCK = 62901925n;
+const ROBINHOOD_SPY_USDG_30BPS_POOL_INFO = {
 	maxPriceDeviation: MAX_PRICE_DEVIATION,
-	pool: ROBINHOOD_DEPLOYMENT$1.panoptic.pool.panopticPool,
-	token0: getSpyUsdgMarket(ROBINHOOD_DEPLOYMENT$1).currency0,
-	token1: getSpyUsdgMarket(ROBINHOOD_DEPLOYMENT$1).currency1,
-	positionScanFromBlock: ROBINHOOD_SPY_USDG_POOL_DEPLOYMENT_BLOCK
+	pool: "0x00000000989bcb6f24af4a1Ab2A6d6a31c98A58E",
+	token0: "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
+	token1: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+	positionScanFromBlock: ROBINHOOD_SPY_USDG_30BPS_POOL_DEPLOYMENT_BLOCK
 };
+const ROBINHOOD_SPY_USDG_5BPS_POOL_DEPLOYMENT_BLOCK = 72457529n;
+const ROBINHOOD_SPY_USDG_5BPS_POOL_INFO = {
+	maxPriceDeviation: MAX_PRICE_DEVIATION,
+	pool: "0x000000000c21b38c54AcA7c7145Df01ff09d69Bb",
+	token0: ROBINHOOD_SPY_USDG_30BPS_POOL_INFO.token0,
+	token1: ROBINHOOD_SPY_USDG_30BPS_POOL_INFO.token1,
+	positionScanFromBlock: ROBINHOOD_SPY_USDG_5BPS_POOL_DEPLOYMENT_BLOCK
+};
+const ROBINHOOD_SPY_USDG_POOL_DEPLOYMENT_BLOCK = ROBINHOOD_SPY_USDG_5BPS_POOL_DEPLOYMENT_BLOCK;
+const ROBINHOOD_SPY_USDG_POOL_INFO = ROBINHOOD_SPY_USDG_5BPS_POOL_INFO;
 /** Accountant order used by the v3-authorization release. */
 const MAINNET_DEFAULT_POOL_INFOS = [MAINNET_ETH_USDC_V4_POOL_INFO, MAINNET_USDC_WETH_5BPS_V3_POOL_INFO];
 const MAINNET_USDC_PLP_POOL_INFOS = [
@@ -25565,130 +25612,159 @@ const UsdcPlpVaultSepoliaProdConfig = {
 
 //#endregion
 //#region src/hypoVault/hypoVaultManagerArtifacts/RobinhoodUSDGPLPStrategistLeaves.ts
-const deployment$1 = requireChainDeployment(ROBINHOOD_CHAIN_ID);
-const vault$1 = deployment$1.hypovault.vaults.usdgPlpVault;
-const manager$1 = deployment$1.hypovault.managers.usdgPlpVaultManager;
-if (vault$1 === void 0 || manager$1 === void 0) throw new Error("Missing Robinhood USDG PLP vault deployment addresses");
-const pool = deployment$1.panoptic.pool.panopticPool;
-const poSpy = deployment$1.panoptic.pool.collateralTracker0;
-const poUsdg = deployment$1.panoptic.pool.collateralTracker1;
-const spy = ROBINHOOD_SPY_USDG_POOL_INFO.token0;
-const usdg = ROBINHOOD_SPY_USDG_POOL_INFO.token1;
+const deployment$2 = requireChainDeployment(ROBINHOOD_CHAIN_ID);
+const vault$1 = deployment$2.hypovault.vaults.usdgPlpVault;
+const manager$1 = deployment$2.hypovault.managers.usdgPlpVaultManager;
+const oldPool = deployment$2.panoptic.additionalPools?.spyUsdg30bpsV4;
+const newPool = deployment$2.panoptic.additionalPools?.spyUsdg5bpsV4;
+if (vault$1 === void 0 || manager$1 === void 0 || oldPool === void 0 || newPool === void 0) throw new Error("Missing Robinhood USDG PLP dual-generation deployment addresses");
+const vaultAddress$2 = vault$1;
+const managerAddress$1 = manager$1;
+const oldPoolAddresses = oldPool;
+const newPoolAddresses = newPool;
 const dispatchSignature = "dispatch(uint256[],uint256[],uint128[],int24[3][],bool,uint256)";
-const trackerLeaves = [
-	{
-		description: "Approve poSPY to spend SPY",
-		target: spy,
-		functionSignature: "approve(address,uint256)",
-		addressArguments: [poSpy],
-		canSendValue: false
-	},
-	{
-		description: "Deposit SPY for poSPY",
-		target: poSpy,
-		functionSignature: "deposit(uint256,address)",
-		addressArguments: [vault$1],
-		canSendValue: false
-	},
-	{
-		description: "Withdraw SPY from poSPY",
-		target: poSpy,
-		functionSignature: "withdraw(uint256,address,address)",
-		addressArguments: [vault$1, vault$1],
-		canSendValue: false
-	},
-	{
-		description: "Withdraw SPY from poSPY (with open positions)",
-		target: poSpy,
-		functionSignature: "withdraw(uint256,address,address,uint256[],bool)",
-		addressArguments: [vault$1, vault$1],
-		canSendValue: false
-	},
-	{
-		description: "Mint poSPY using SPY",
-		target: poSpy,
-		functionSignature: "mint(uint256,address)",
-		addressArguments: [vault$1],
-		canSendValue: false
-	},
-	{
-		description: "Redeem poSPY for SPY",
-		target: poSpy,
-		functionSignature: "redeem(uint256,address,address)",
-		addressArguments: [vault$1, vault$1],
-		canSendValue: false
-	},
-	{
-		description: "Approve poUSDG to spend USDG",
-		target: usdg,
-		functionSignature: "approve(address,uint256)",
-		addressArguments: [poUsdg],
-		canSendValue: false
-	},
-	{
-		description: "Deposit USDG for poUSDG",
-		target: poUsdg,
-		functionSignature: "deposit(uint256,address)",
-		addressArguments: [vault$1],
-		canSendValue: false
-	},
-	{
-		description: "Withdraw USDG from poUSDG",
-		target: poUsdg,
-		functionSignature: "withdraw(uint256,address,address)",
-		addressArguments: [vault$1, vault$1],
-		canSendValue: false
-	},
-	{
-		description: "Withdraw USDG from poUSDG (with open positions)",
-		target: poUsdg,
-		functionSignature: "withdraw(uint256,address,address,uint256[],bool)",
-		addressArguments: [vault$1, vault$1],
-		canSendValue: false
-	},
-	{
-		description: "Mint poUSDG using USDG",
-		target: poUsdg,
-		functionSignature: "mint(uint256,address)",
-		addressArguments: [vault$1],
-		canSendValue: false
-	},
-	{
-		description: "Redeem poUSDG for USDG",
-		target: poUsdg,
-		functionSignature: "redeem(uint256,address,address)",
-		addressArguments: [vault$1, vault$1],
+function createPolicy({ id, poolInfo, collateralTracker0, collateralTracker1 }) {
+	const trackerLeaves = [
+		{
+			description: "Approve poSPY to spend SPY",
+			target: poolInfo.token0,
+			functionSignature: "approve(address,uint256)",
+			addressArguments: [collateralTracker0],
+			canSendValue: false
+		},
+		{
+			description: "Deposit SPY for poSPY",
+			target: collateralTracker0,
+			functionSignature: "deposit(uint256,address)",
+			addressArguments: [vaultAddress$2],
+			canSendValue: false
+		},
+		{
+			description: "Withdraw SPY from poSPY",
+			target: collateralTracker0,
+			functionSignature: "withdraw(uint256,address,address)",
+			addressArguments: [vaultAddress$2, vaultAddress$2],
+			canSendValue: false
+		},
+		{
+			description: "Withdraw SPY from poSPY (with open positions)",
+			target: collateralTracker0,
+			functionSignature: "withdraw(uint256,address,address,uint256[],bool)",
+			addressArguments: [vaultAddress$2, vaultAddress$2],
+			canSendValue: false
+		},
+		{
+			description: "Mint poSPY using SPY",
+			target: collateralTracker0,
+			functionSignature: "mint(uint256,address)",
+			addressArguments: [vaultAddress$2],
+			canSendValue: false
+		},
+		{
+			description: "Redeem poSPY for SPY",
+			target: collateralTracker0,
+			functionSignature: "redeem(uint256,address,address)",
+			addressArguments: [vaultAddress$2, vaultAddress$2],
+			canSendValue: false
+		},
+		{
+			description: "Approve poUSDG to spend USDG",
+			target: poolInfo.token1,
+			functionSignature: "approve(address,uint256)",
+			addressArguments: [collateralTracker1],
+			canSendValue: false
+		},
+		{
+			description: "Deposit USDG for poUSDG",
+			target: collateralTracker1,
+			functionSignature: "deposit(uint256,address)",
+			addressArguments: [vaultAddress$2],
+			canSendValue: false
+		},
+		{
+			description: "Withdraw USDG from poUSDG",
+			target: collateralTracker1,
+			functionSignature: "withdraw(uint256,address,address)",
+			addressArguments: [vaultAddress$2, vaultAddress$2],
+			canSendValue: false
+		},
+		{
+			description: "Withdraw USDG from poUSDG (with open positions)",
+			target: collateralTracker1,
+			functionSignature: "withdraw(uint256,address,address,uint256[],bool)",
+			addressArguments: [vaultAddress$2, vaultAddress$2],
+			canSendValue: false
+		},
+		{
+			description: "Mint poUSDG using USDG",
+			target: collateralTracker1,
+			functionSignature: "mint(uint256,address)",
+			addressArguments: [vaultAddress$2],
+			canSendValue: false
+		},
+		{
+			description: "Redeem poUSDG for USDG",
+			target: collateralTracker1,
+			functionSignature: "redeem(uint256,address,address)",
+			addressArguments: [vaultAddress$2, vaultAddress$2],
+			canSendValue: false
+		}
+	];
+	const dispatchLeaf = {
+		description: "Dispatch mint/burn options on PanopticPool",
+		target: poolInfo.pool,
+		functionSignature: dispatchSignature,
+		addressArguments: [],
 		canSendValue: false
-	}
-];
-const dispatchLeaf = {
-	description: "Dispatch mint/burn options on PanopticPool",
-	target: pool,
-	functionSignature: dispatchSignature,
-	addressArguments: [],
-	canSendValue: false
-};
-const windDownLeaves = trackerLeaves.filter(({ functionSignature }) => functionSignature.startsWith("withdraw(") || functionSignature.startsWith("redeem("));
-const ROBINHOOD_USDG_PLP_POOL_POLICY = [{
-	id: "spy-usdg-v4",
-	mode: "primary",
-	poolInfo: ROBINHOOD_SPY_USDG_POOL_INFO,
-	fullLeafDefinitions: [...trackerLeaves, dispatchLeaf],
-	windDownLeafDefinitions: [...windDownLeaves, dispatchLeaf]
-}];
-const ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY = compileVaultPoolPolicy({ pools: ROBINHOOD_USDG_PLP_POOL_POLICY });
-const RobinhoodUSDGPLPStrategistLeaves = createStrategistLeavesArtifact({
-	accountantAddress: deployment$1.hypovault.core.accountant,
-	boringVaultAddress: vault$1,
-	decoderAndSanitizerAddress: deployment$1.hypovault.core.collateralTrackerDecoderAndSanitizer,
-	managerAddress: manager$1
-}, ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY.strategistLeafDefinitions);
+	};
+	const windDownLeaves = trackerLeaves.filter(({ functionSignature }) => functionSignature.startsWith("withdraw(") || functionSignature.startsWith("redeem("));
+	return [{
+		id,
+		mode: "primary",
+		poolInfo,
+		fullLeafDefinitions: [...trackerLeaves, dispatchLeaf],
+		windDownLeafDefinitions: [...windDownLeaves, dispatchLeaf]
+	}];
+}
+function createArtifact(policy) {
+	const compiled = compileVaultPoolPolicy({ pools: policy });
+	return {
+		compiled,
+		artifact: createStrategistLeavesArtifact({
+			accountantAddress: deployment$2.hypovault.core.accountant,
+			boringVaultAddress: vaultAddress$2,
+			decoderAndSanitizerAddress: deployment$2.hypovault.core.collateralTrackerDecoderAndSanitizer,
+			managerAddress: managerAddress$1
+		}, compiled.strategistLeafDefinitions)
+	};
+}
+const ROBINHOOD_USDG_PLP_30BPS_POOL_POLICY = createPolicy({
+	id: "spy-usdg-30bps-v4",
+	poolInfo: ROBINHOOD_SPY_USDG_30BPS_POOL_INFO,
+	collateralTracker0: oldPoolAddresses.collateralTracker0,
+	collateralTracker1: oldPoolAddresses.collateralTracker1
+});
+const ROBINHOOD_USDG_PLP_5BPS_POOL_POLICY = createPolicy({
+	id: "spy-usdg-5bps-v4",
+	poolInfo: ROBINHOOD_SPY_USDG_5BPS_POOL_INFO,
+	collateralTracker0: newPoolAddresses.collateralTracker0,
+	collateralTracker1: newPoolAddresses.collateralTracker1
+});
+const previous = createArtifact(ROBINHOOD_USDG_PLP_30BPS_POOL_POLICY);
+const next = createArtifact(ROBINHOOD_USDG_PLP_5BPS_POOL_POLICY);
+const ROBINHOOD_USDG_PLP_30BPS_COMPILED_POOL_POLICY = previous.compiled;
+const ROBINHOOD_USDG_PLP_5BPS_COMPILED_POOL_POLICY = next.compiled;
+const RobinhoodUSDGPLP30bpsStrategistLeaves = previous.artifact;
+const RobinhoodUSDGPLP5bpsStrategistLeaves = next.artifact;
+const ROBINHOOD_USDG_PLP_POOL_POLICY = ROBINHOOD_USDG_PLP_5BPS_POOL_POLICY;
+const ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY = ROBINHOOD_USDG_PLP_5BPS_COMPILED_POOL_POLICY;
+const RobinhoodUSDGPLPStrategistLeaves = RobinhoodUSDGPLP5bpsStrategistLeaves;
 
 //#endregion
 //#region src/hypoVault/hypoVaultManagerConfigs/usdgPlpVaultRobinhoodProdConfig.ts
-const deployment = requireChainDeployment(ROBINHOOD_CHAIN_ID);
-const vault = deployment.hypovault.vaults.usdgPlpVault;
-const manager = deployment.hypovault.managers.usdgPlpVaultManager;
+const deployment$1 = requireChainDeployment(ROBINHOOD_CHAIN_ID);
+const vault = deployment$1.hypovault.vaults.usdgPlpVault;
+const manager = deployment$1.hypovault.managers.usdgPlpVaultManager;
 if (vault === void 0 || manager === void 0) throw new Error("Missing Robinhood USDG PLP vault deployment addresses");
 const UsdgPlpVaultRobinhoodProdConfig = {
 	deployment: "prod",
@@ -25703,19 +25779,19 @@ const UsdgPlpVaultRobinhoodProdConfig = {
 	chainId: ROBINHOOD_CHAIN_ID,
 	hypoVaultAddress: vault,
 	addresses: {
-		ethUsdc500bpsV4Collateral0: deployment.panoptic.pool.collateralTracker0,
-		ethUsdc500bpsV4Collateral1: deployment.panoptic.pool.collateralTracker1,
-		ethUsdc500bpsV4PanopticPool: deployment.panoptic.pool.panopticPool,
+		ethUsdc500bpsV4Collateral0: deployment$1.panoptic.pool.collateralTracker0,
+		ethUsdc500bpsV4Collateral1: deployment$1.panoptic.pool.collateralTracker1,
+		ethUsdc500bpsV4PanopticPool: deployment$1.panoptic.pool.panopticPool,
 		hypoVaultManagerWithMerkleVerification: manager,
 		hypoVault: vault,
-		underlyingToken: getSpyUsdgMarket(deployment).currency1
+		underlyingToken: getSpyUsdgMarket(deployment$1).currency1
 	},
 	automation: {
 		primaryPool: ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY.automation.primaryPool,
 		windDownPools: [...ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY.automation.windDownPools]
 	},
 	manualTxDefaults: { collateralAllocations: [{
-		trackerAddress: deployment.panoptic.pool.collateralTracker1,
+		trackerAddress: deployment$1.panoptic.pool.collateralTracker1,
 		allocationBps: 1e4
 	}] },
 	deltaHedge: {
@@ -26170,8 +26246,8 @@ const ALL_HYPO_VAULT_CONFIGS = [
 	UsdcPlpVaultMainnetLegacyConfig,
 	UsdgPlpVaultRobinhoodProdConfig
 ];
-function getHypoVaultConfigForVault(vaultAddress$1, chainId, options) {
-	const vaultLower = vaultAddress$1.toLowerCase();
+function getHypoVaultConfigForVault(vaultAddress$3, chainId, options) {
+	const vaultLower = vaultAddress$3.toLowerCase();
 	const matchingConfigs = ALL_HYPO_VAULT_CONFIGS.filter((c) => c.hypoVaultAddress?.toLowerCase() === vaultLower && c.chainId === chainId);
 	if (matchingConfigs.length === 0) return void 0;
 	const preferredDeployment = options?.preferredDeployment;
@@ -26493,7 +26569,7 @@ function isSnapshotCandidateEvent(event) {
 	return event.transactionHash !== null && event.blockNumber !== null && event.logIndex !== null;
 }
 function decodeSnapshotTransaction(params) {
-	const { account, pool: pool$1, rolesContext } = params;
+	const { account, pool, rolesContext } = params;
 	let dispatchInput = params.input;
 	let dispatchSender = params.from;
 	if (rolesContext) {
@@ -26504,14 +26580,14 @@ function decodeSnapshotTransaction(params) {
 				data: params.input
 			});
 			const [target, value, data, operation, roleKey, shouldRevert] = decodedRoleCall.args;
-			if (!pool$1 || getAddress(target) !== getAddress(pool$1) || value !== 0n || operation !== 0 || roleKey.toLowerCase() !== rolesContext.roleKey.toLowerCase() || !shouldRevert) return null;
+			if (!pool || getAddress(target) !== getAddress(pool) || value !== 0n || operation !== 0 || roleKey.toLowerCase() !== rolesContext.roleKey.toLowerCase() || !shouldRevert) return null;
 			dispatchInput = data;
 			if (!account) return null;
 			dispatchSender = account;
 		} catch {
 			return null;
 		}
-	} else if (pool$1 && (params.to === null || getAddress(params.to) !== getAddress(pool$1))) return null;
+	} else if (pool && (params.to === null || getAddress(params.to) !== getAddress(pool))) return null;
 	const candidates = decodeAllDispatchCalldata(dispatchInput);
 	if (candidates.length === 0) return null;
 	return account ? selectDispatchForAccount(candidates, account, dispatchSender) : candidates[candidates.length - 1];
@@ -26539,7 +26615,7 @@ function decodeSnapshotTransaction(params) {
 * ```
 */
 async function recoverSnapshotFromTx(params) {
-	const { client, transactionHash, account, pool: pool$1, rolesContext } = params;
+	const { client, transactionHash, account, pool, rolesContext } = params;
 	const tx = await client.getTransaction({ hash: transactionHash });
 	if (tx.blockNumber == null) return null;
 	const decoded = decodeSnapshotTransaction({
@@ -26547,7 +26623,7 @@ async function recoverSnapshotFromTx(params) {
 		from: tx.from,
 		to: tx.to,
 		account,
-		pool: pool$1,
+		pool,
 		rolesContext
 	});
 	if (!decoded) return null;
@@ -26837,12 +26913,18 @@ const MainnetWETHPLPLegacyVaultPoolInfos = {
 
 //#endregion
 //#region src/hypoVault/hypoVaultManagerArtifacts/RobinhoodUSDGPLPVaultPoolInfos.ts
-const vaultAddress = requireChainDeployment(ROBINHOOD_CHAIN_ID).hypovault.vaults.usdgPlpVault;
-if (vaultAddress === void 0) throw new Error("Missing Robinhood USDG PLP vault address");
-const RobinhoodUSDGPLPVaultPoolInfos = {
-	vaultAddress,
-	poolInfos: ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY.poolInfos.map((poolInfo) => ({ ...poolInfo }))
-};
+const vaultAddress$1 = requireChainDeployment(ROBINHOOD_CHAIN_ID).hypovault.vaults.usdgPlpVault;
+if (vaultAddress$1 === void 0) throw new Error("Missing Robinhood USDG PLP vault address");
+const resolvedVaultAddress$1 = vaultAddress$1;
+function createVaultPoolInfos(poolInfos) {
+	return {
+		vaultAddress: resolvedVaultAddress$1,
+		poolInfos: poolInfos.map((poolInfo) => ({ ...poolInfo }))
+	};
+}
+const RobinhoodUSDGPLP30bpsVaultPoolInfos = createVaultPoolInfos(ROBINHOOD_USDG_PLP_30BPS_COMPILED_POOL_POLICY.poolInfos);
+const RobinhoodUSDGPLP5bpsVaultPoolInfos = createVaultPoolInfos(ROBINHOOD_USDG_PLP_5BPS_COMPILED_POOL_POLICY.poolInfos);
+const RobinhoodUSDGPLPVaultPoolInfos = RobinhoodUSDGPLP5bpsVaultPoolInfos;
 
 //#endregion
 //#region src/hypoVault/hypoVaultManagerArtifacts/SepoliaUSDCPLPVaultPoolInfos.ts
@@ -26869,7 +26951,7 @@ const SepoliaWETHPLPVaultPoolInfos = {
 const MAINNET_DEPLOYMENT$2 = requireChainDeployment(MAINNET_CHAIN_ID);
 /** Block containing the successful V3 accountant-hash and manager-root update. */
 const MAINNET_V3_AUTHORIZATION_BLOCK = 25704951n;
-const POOL_INFO_ARRAY_ABI$1 = {
+const POOL_INFO_ARRAY_ABI$2 = {
 	type: "tuple[]",
 	components: [
 		{
@@ -26910,7 +26992,7 @@ function createVaultTransition(transition) {
 	};
 }
 function hashPoolInfos$1(poolInfos) {
-	return keccak256(encodeAbiParameters([POOL_INFO_ARRAY_ABI$1], [poolInfos.map((poolInfo) => ({
+	return keccak256(encodeAbiParameters([POOL_INFO_ARRAY_ABI$2], [poolInfos.map((poolInfo) => ({
 		pool: getAddress(poolInfo.pool),
 		token0: getAddress(poolInfo.token0),
 		token1: getAddress(poolInfo.token1),
@@ -26943,14 +27025,14 @@ const MAINNET_V3_AUTHORIZATION_TRANSITIONS = [createVaultTransition({
 	current: generation(MainnetUSDCPLPVaultPoolInfos.poolInfos, MainnetUSDCPLPStrategistLeaves)
 })];
 const authorizationCacheByClient = new WeakMap();
-function findTransition(chainId, vaultAddress$1) {
+function findTransition(chainId, vaultAddress$3) {
 	if (chainId !== MAINNET_CHAIN_ID) return null;
-	const normalizedVault = vaultAddress$1.toLowerCase();
+	const normalizedVault = vaultAddress$3.toLowerCase();
 	return MAINNET_V3_AUTHORIZATION_TRANSITIONS.find((transition) => transition.vaultAddress.toLowerCase() === normalizedVault) ?? null;
 }
 /** Returns both known generations without reading chain state. */
-function getMainnetV3AuthorizationGenerations({ chainId, vaultAddress: vaultAddress$1 }) {
-	const transition = findTransition(chainId, vaultAddress$1);
+function getMainnetV3AuthorizationGenerations({ chainId, vaultAddress: vaultAddress$3 }) {
+	const transition = findTransition(chainId, vaultAddress$3);
 	return transition === null ? null : {
 		previous: transition.previous,
 		next: transition.next,
@@ -26962,8 +27044,8 @@ function getMainnetV3AuthorizationGenerations({ chainId, vaultAddress: vaultAddr
 * Live callers should use the compiled current artifacts directly; this selector exists for
 * block-pinned NAV and manager-input reconstruction across the V3 authorization boundary.
 */
-function getMainnetV3AuthorizationArtifactsAtBlock({ chainId, vaultAddress: vaultAddress$1, blockNumber }) {
-	const transition = findTransition(chainId, vaultAddress$1);
+function getMainnetV3AuthorizationArtifactsAtBlock({ chainId, vaultAddress: vaultAddress$3, blockNumber }) {
+	const transition = findTransition(chainId, vaultAddress$3);
 	if (transition === null) return null;
 	const version = blockNumber < transition.activationBlockNumber ? "previous" : "next";
 	return {
@@ -26979,11 +27061,11 @@ function getMainnetV3AuthorizationArtifactsAtBlock({ chainId, vaultAddress: vaul
 * Every authorization release must add its generation to this transition table before
 * the on-chain hashes change, so startup and release verification keeps recognizing it.
 */
-async function resolveMainnetV3AuthorizationArtifacts({ viemClient, chainId, vaultAddress: vaultAddress$1, blockNumber }) {
-	const transition = findTransition(chainId, vaultAddress$1);
+async function resolveMainnetV3AuthorizationArtifacts({ viemClient, chainId, vaultAddress: vaultAddress$3, blockNumber }) {
+	const transition = findTransition(chainId, vaultAddress$3);
 	if (transition === null) return null;
 	const resolvedBlockNumber = blockNumber ?? await getBlockNumber(viemClient);
-	const cacheKey = `${chainId}:${vaultAddress$1.toLowerCase()}:${resolvedBlockNumber.toString()}`;
+	const cacheKey = `${chainId}:${vaultAddress$3.toLowerCase()}:${resolvedBlockNumber.toString()}`;
 	const clientCache = authorizationCacheByClient.get(viemClient);
 	const cached = clientCache?.get(cacheKey);
 	if (cached !== void 0) return cached;
@@ -27020,7 +27102,7 @@ const MAINNET_POOL_RETIREMENT_BLOCK = 25898997n;
 const MAINNET_POOL_RETIREMENT_TRANSACTION = "0xfca6a6dd0f081649dd6f50496175a58e6a119d574b594390beab23618b05ba2c";
 const ROBINHOOD_USDG_VAULT_DEPLOYMENT_BLOCK = 63972776n;
 const ROBINHOOD_USDG_VAULT_DEPLOYMENT_TRANSACTION = "0x738c8a6d30a45f9b71d2d6260aa1c04aff558489631b3a9c6ccd5f49e0f57df4";
-const POOL_INFO_ARRAY_ABI = {
+const POOL_INFO_ARRAY_ABI$1 = {
 	type: "tuple[]",
 	components: [
 		{
@@ -27042,7 +27124,7 @@ const POOL_INFO_ARRAY_ABI = {
 	]
 };
 function hashPoolInfos(poolInfos) {
-	return keccak256(encodeAbiParameters([POOL_INFO_ARRAY_ABI], [poolInfos.map((poolInfo) => ({
+	return keccak256(encodeAbiParameters([POOL_INFO_ARRAY_ABI$1], [poolInfos.map((poolInfo) => ({
 		pool: getAddress(poolInfo.pool),
 		token0: getAddress(poolInfo.token0),
 		token1: getAddress(poolInfo.token1),
@@ -27139,8 +27221,8 @@ const MAINNET_VAULT_HISTORIES = [{
 	]
 }];
 const ROBINHOOD_VAULT_HISTORIES = [{
-	vaultAddress: RobinhoodUSDGPLPVaultPoolInfos.vaultAddress,
-	poolConfigurations: [poolConfiguration(ROBINHOOD_USDG_VAULT_DEPLOYMENT_BLOCK, ROBINHOOD_USDG_VAULT_DEPLOYMENT_TRANSACTION, RobinhoodUSDGPLPVaultPoolInfos.poolInfos)],
+	vaultAddress: RobinhoodUSDGPLP30bpsVaultPoolInfos.vaultAddress,
+	poolConfigurations: [poolConfiguration(ROBINHOOD_USDG_VAULT_DEPLOYMENT_BLOCK, ROBINHOOD_USDG_VAULT_DEPLOYMENT_TRANSACTION, RobinhoodUSDGPLP30bpsVaultPoolInfos.poolInfos)],
 	managerRootTransitions: [{
 		activationBlockNumber: ROBINHOOD_USDG_VAULT_DEPLOYMENT_BLOCK,
 		transactionHash: ROBINHOOD_USDG_VAULT_DEPLOYMENT_TRANSACTION,
@@ -27163,10 +27245,10 @@ function copyHistory(history) {
 		managerRootTransitions: history.managerRootTransitions.map(copyManagerRootTransition)
 	};
 }
-function findHistory(chainId, vaultAddress$1) {
+function findHistory(chainId, vaultAddress$3) {
 	const histories = chainId === MAINNET_CHAIN_ID ? MAINNET_VAULT_HISTORIES : chainId === ROBINHOOD_CHAIN_ID ? ROBINHOOD_VAULT_HISTORIES : null;
 	if (histories === null) return null;
-	const normalizedVault = vaultAddress$1.toLowerCase();
+	const normalizedVault = vaultAddress$3.toLowerCase();
 	const history = histories.find((candidate) => candidate.vaultAddress.toLowerCase() === normalizedVault);
 	return history === void 0 ? null : copyHistory(history);
 }
@@ -27177,19 +27259,117 @@ function latestAtBlock(values, blockNumber) {
 	}
 	return null;
 }
-function getMainnetVaultPoolConfigurationAtBlock({ chainId, vaultAddress: vaultAddress$1, blockNumber }) {
-	const history = findHistory(chainId, vaultAddress$1);
+function getVaultPoolConfigurationAtBlock({ chainId, vaultAddress: vaultAddress$3, blockNumber }) {
+	const history = findHistory(chainId, vaultAddress$3);
 	return history === null ? null : latestAtBlock(history.poolConfigurations, blockNumber);
 }
-function getMainnetVaultManagerRootAtBlock({ chainId, vaultAddress: vaultAddress$1, blockNumber }) {
-	const history = findHistory(chainId, vaultAddress$1);
+function getVaultManagerRootAtBlock({ chainId, vaultAddress: vaultAddress$3, blockNumber }) {
+	const history = findHistory(chainId, vaultAddress$3);
 	return history === null ? null : latestAtBlock(history.managerRootTransitions, blockNumber);
 }
-function getMainnetVaultPoolConfigurationHistory({ chainId, vaultAddress: vaultAddress$1 }) {
-	return findHistory(chainId, vaultAddress$1)?.poolConfigurations ?? null;
+function getVaultPoolConfigurationHistory({ chainId, vaultAddress: vaultAddress$3 }) {
+	return findHistory(chainId, vaultAddress$3)?.poolConfigurations ?? null;
+}
+function getVaultManagerRootHistory({ chainId, vaultAddress: vaultAddress$3 }) {
+	return findHistory(chainId, vaultAddress$3)?.managerRootTransitions ?? null;
+}
+const getMainnetVaultPoolConfigurationAtBlock = getVaultPoolConfigurationAtBlock;
+const getMainnetVaultManagerRootAtBlock = getVaultManagerRootAtBlock;
+const getMainnetVaultPoolConfigurationHistory = getVaultPoolConfigurationHistory;
+const getMainnetVaultManagerRootHistory = getVaultManagerRootHistory;
+
+//#endregion
+//#region src/hypoVault/robinhoodSpyUsdgAuthorization.ts
+const deployment = requireChainDeployment(ROBINHOOD_CHAIN_ID);
+const vaultAddress = deployment.hypovault.vaults.usdgPlpVault;
+const managerAddress = deployment.hypovault.managers.usdgPlpVaultManager;
+const strategistAddress = deployment.hypovault.turnkeySigners.usdgPlpVaultManager;
+if (vaultAddress === void 0 || managerAddress === void 0 || strategistAddress === void 0) throw new Error("Missing Robinhood USDG authorization addresses");
+const resolvedVaultAddress = vaultAddress;
+const resolvedManagerAddress = managerAddress;
+const resolvedStrategistAddress = strategistAddress;
+const POOL_INFO_ARRAY_ABI = {
+	type: "tuple[]",
+	components: [
+		{
+			name: "pool",
+			type: "address"
+		},
+		{
+			name: "token0",
+			type: "address"
+		},
+		{
+			name: "token1",
+			type: "address"
+		},
+		{
+			name: "maxPriceDeviation",
+			type: "int24"
+		}
+	]
+};
+const ROBINHOOD_USDG_30BPS_MANAGE_ROOT = "0x5ef821042a85fea05901e4612e8a8d60efd2468ca08f0810d5691e23ea98967f";
+const ROBINHOOD_USDG_30BPS_POOL_HASH = "0x12b0d7232a6250eb3cf61040edbf4015717756c4819926aedc3670a4217e56cc";
+const ROBINHOOD_USDG_5BPS_POOL_HASH = "0xc5dcfa7ae982f641493c9f848bb93cb138a1ad5b3bc13c309b7625850af8562b";
+function hashRobinhoodSpyUsdgPoolInfos(poolInfos) {
+	return keccak256(encodeAbiParameters([POOL_INFO_ARRAY_ABI], [poolInfos.map((poolInfo) => ({
+		pool: getAddress(poolInfo.pool),
+		token0: getAddress(poolInfo.token0),
+		token1: getAddress(poolInfo.token1),
+		maxPriceDeviation: poolInfo.maxPriceDeviation
+	}))]));
+}
+const generations = [{
+	version: "30bps",
+	poolInfos: RobinhoodUSDGPLP30bpsVaultPoolInfos.poolInfos,
+	strategistLeaves: RobinhoodUSDGPLP30bpsStrategistLeaves,
+	poolHash: ROBINHOOD_USDG_30BPS_POOL_HASH,
+	manageRoot: ROBINHOOD_USDG_30BPS_MANAGE_ROOT
+}, {
+	version: "5bps",
+	poolInfos: RobinhoodUSDGPLP5bpsVaultPoolInfos.poolInfos,
+	strategistLeaves: RobinhoodUSDGPLP5bpsStrategistLeaves,
+	poolHash: ROBINHOOD_USDG_5BPS_POOL_HASH,
+	manageRoot: RobinhoodUSDGPLP5bpsStrategistLeaves.metadata.ManageRoot
+}];
+for (const generation$1 of generations) {
+	const computedPoolHash = hashRobinhoodSpyUsdgPoolInfos(generation$1.poolInfos);
+	if (computedPoolHash !== generation$1.poolHash) throw new Error(`Robinhood ${generation$1.version} pool hash mismatch: expected ${generation$1.poolHash}, computed ${computedPoolHash}`);
+}
+if (RobinhoodUSDGPLP30bpsStrategistLeaves.metadata.ManageRoot !== ROBINHOOD_USDG_30BPS_MANAGE_ROOT) throw new Error("Robinhood 30bps strategist artifact no longer reproduces the live manage root");
+function getRobinhoodSpyUsdgAuthorizationGenerations() {
+	return generations;
 }
-function getMainnetVaultManagerRootHistory({ chainId, vaultAddress: vaultAddress$1 }) {
-	return findHistory(chainId, vaultAddress$1)?.managerRootTransitions ?? null;
+function resolveRobinhoodSpyUsdgAuthorizationState({ blockNumber, poolHash, manageRoot }) {
+	const generation$1 = generations.find((candidate) => candidate.poolHash === poolHash && candidate.manageRoot === manageRoot);
+	if (generation$1 === void 0) throw new Error(`Unsupported or inconsistent Robinhood SPY/USDG authorization state: accountant pool hash ${poolHash}, manager root ${manageRoot}`);
+	return {
+		blockNumber,
+		...generation$1
+	};
+}
+async function resolveRobinhoodSpyUsdgAuthorizationArtifacts({ viemClient, chainId, vault: vault$2, blockNumber }) {
+	if (chainId !== ROBINHOOD_CHAIN_ID || vault$2.toLowerCase() !== resolvedVaultAddress.toLowerCase()) return null;
+	const resolvedBlockNumber = blockNumber ?? await getBlockNumber(viemClient);
+	const [poolHash, manageRoot] = await Promise.all([readContract(viemClient, {
+		address: deployment.hypovault.core.accountant,
+		abi: PanopticVaultAccountantAbi,
+		functionName: "vaultHashes",
+		args: [resolvedVaultAddress, 0n],
+		blockNumber: resolvedBlockNumber
+	}), readContract(viemClient, {
+		address: resolvedManagerAddress,
+		abi: HypoVaultManagerWithMerkleVerificationAbi,
+		functionName: "manageRoot",
+		args: [resolvedStrategistAddress],
+		blockNumber: resolvedBlockNumber
+	})]);
+	return resolveRobinhoodSpyUsdgAuthorizationState({
+		blockNumber: resolvedBlockNumber,
+		poolHash,
+		manageRoot
+	});
 }
 
 //#endregion
@@ -27320,7 +27500,7 @@ const VAULT_POOL_INFOS_BY_CHAIN = {
 	],
 	[SEPOLIA_CHAIN_ID]: [SepoliaUSDCPLPVaultPoolInfos, SepoliaWETHPLPVaultPoolInfos],
 	[BASE_CHAIN_ID]: [BaseUSDCPLPVaultPoolInfos, BaseWETHPLPVaultPoolInfos],
-	[ROBINHOOD_CHAIN_ID]: [RobinhoodUSDGPLPVaultPoolInfos]
+	[ROBINHOOD_CHAIN_ID]: [RobinhoodUSDGPLP5bpsVaultPoolInfos, RobinhoodUSDGPLP30bpsVaultPoolInfos]
 };
 const GET_POOL_ACCOUNT_BALANCE_CANDIDATES = `
   query PoolAccountBalanceCandidates(
@@ -27418,7 +27598,7 @@ async function postGraphQL({ endpoint, query, variables, fetchFn }) {
 	if (json.data === void 0) throw new Error("GraphQL response did not include data");
 	return json.data;
 }
-async function collectPoolAccountBalanceCandidates({ endpoint, poolIds, vaultAddress: vaultAddress$1, candidatesByPool, fetchFn }) {
+async function collectPoolAccountBalanceCandidates({ endpoint, poolIds, vaultAddress: vaultAddress$3, candidatesByPool, fetchFn }) {
 	for (let skip = 0;; skip += PAGE_SIZE) {
 		const page = await postGraphQL({
 			endpoint,
@@ -27427,7 +27607,7 @@ async function collectPoolAccountBalanceCandidates({ endpoint, poolIds, vaultAdd
 				first: PAGE_SIZE,
 				skip,
 				poolIds,
-				vault: vaultAddress$1
+				vault: vaultAddress$3
 			},
 			fetchFn
 		});
@@ -27527,8 +27707,8 @@ async function filterOpenTokenIdsAtBlock({ viemClient, poolAddress, account, can
 	const openTokenIds = await collectOpen(candidates);
 	return sortBigintsAscending(openTokenIds);
 }
-function getVaultPoolInfos(vaultAddress$1, chainId) {
-	const vaultAddressLower = toLowerAddress$1(vaultAddress$1);
+function getVaultPoolInfos(vaultAddress$3, chainId) {
+	const vaultAddressLower = toLowerAddress$1(vaultAddress$3);
 	const artifacts = chainId === void 0 ? Object.values(VAULT_POOL_INFOS_BY_CHAIN).flat() : VAULT_POOL_INFOS_BY_CHAIN[chainId] ?? [];
 	const artifact = artifacts.find((candidate) => toLowerAddress$1(candidate.vaultAddress) === vaultAddressLower);
 	return artifact?.poolInfos ?? [];
@@ -27537,15 +27717,24 @@ function getVaultPoolInfos(vaultAddress$1, chainId) {
 * Returns every pool that can contribute historical position candidates for a vault.
 * The live accountant generation is selected separately when encoding manager input.
 */
-function getVaultCandidatePoolInfos(vaultAddress$1, chainId) {
-	const generations = getMainnetV3AuthorizationGenerations({
+function getVaultCandidatePoolInfos(vaultAddress$3, chainId) {
+	const generations$1 = getMainnetV3AuthorizationGenerations({
 		chainId,
-		vaultAddress: vaultAddress$1
+		vaultAddress: vaultAddress$3
 	});
-	const candidates = generations === null ? getVaultPoolInfos(vaultAddress$1, chainId) : [
-		...generations.previous.poolInfos,
-		...generations.next.poolInfos,
-		...generations.current.poolInfos
+	const robinhoodGenerations = chainId === ROBINHOOD_CHAIN_ID ? getRobinhoodSpyUsdgAuthorizationGenerations() : [];
+	const history = getVaultPoolConfigurationHistory({
+		chainId,
+		vaultAddress: vaultAddress$3
+	}) ?? [];
+	const candidates = [
+		...history.flatMap(({ poolInfos }) => poolInfos),
+		...generations$1 === null ? getVaultPoolInfos(vaultAddress$3, chainId) : [
+			...generations$1.previous.poolInfos,
+			...generations$1.next.poolInfos,
+			...generations$1.current.poolInfos
+		],
+		...robinhoodGenerations.flatMap((generation$1) => generation$1.poolInfos)
 	];
 	const byPoolAddress = new Map();
 	for (const candidate of candidates) {
@@ -27555,21 +27744,30 @@ function getVaultCandidatePoolInfos(vaultAddress$1, chainId) {
 	return [...byPoolAddress.values()];
 }
 /** Selects the pool tuple authorized at an exact block before encoding manager input. */
-async function resolveVaultPoolInfosAtBlock({ viemClient, chainId, vaultAddress: vaultAddress$1, blockNumber }) {
+async function resolveVaultPoolInfosAtBlock({ viemClient, chainId, vaultAddress: vaultAddress$3, blockNumber }) {
+	if (chainId === ROBINHOOD_CHAIN_ID && blockNumber >= ROBINHOOD_USDG_VAULT_DEPLOYMENT_BLOCK) {
+		const authorization = await resolveRobinhoodSpyUsdgAuthorizationArtifacts({
+			viemClient,
+			chainId,
+			vault: vaultAddress$3,
+			blockNumber
+		});
+		if (authorization !== null) return authorization.poolInfos;
+	}
 	if (chainId === MAINNET_CHAIN_ID && blockNumber >= MAINNET_V3_AUTHORIZATION_BLOCK) {
 		const authorization = await resolveMainnetV3AuthorizationArtifacts({
 			viemClient,
 			chainId,
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			blockNumber
 		});
 		if (authorization !== null) return authorization.poolInfos;
 	}
-	return getMainnetVaultPoolConfigurationAtBlock({
+	return getVaultPoolConfigurationAtBlock({
 		chainId,
-		vaultAddress: vaultAddress$1,
+		vaultAddress: vaultAddress$3,
 		blockNumber
-	})?.poolInfos ?? getVaultPoolInfos(vaultAddress$1, chainId);
+	})?.poolInfos ?? getVaultPoolInfos(vaultAddress$3, chainId);
 }
 /**
 * Enrich a cached subgraph candidate superset with the authoritative position
@@ -27581,7 +27779,7 @@ async function resolveVaultPoolInfosAtBlock({ viemClient, chainId, vaultAddress:
 * all-time candidate cache; closed IDs remain harmless because the normal
 * per-block verifier filters them out.
 */
-async function recoverVaultCandidateTokenIdsByPool({ viemClient, chainId, vaultAddress: vaultAddress$1, candidatesByPool, poolInfos, blockNumber, fromBlock }) {
+async function recoverVaultCandidateTokenIdsByPool({ viemClient, chainId, vaultAddress: vaultAddress$3, candidatesByPool, poolInfos, blockNumber, fromBlock }) {
 	return Promise.all(poolInfos.map(async (poolInfo) => {
 		const cached = candidatesByPool.find((candidate) => candidate.poolAddress.toLowerCase() === poolInfo.pool.toLowerCase());
 		const cachedIds = cached?.candidates ?? [];
@@ -27595,11 +27793,11 @@ async function recoverVaultCandidateTokenIdsByPool({ viemClient, chainId, vaultA
 			client: viemClient,
 			chainId: BigInt(chainId),
 			poolAddress: poolInfo.pool,
-			account: vaultAddress$1,
+			account: vaultAddress$3,
 			fromBlock: scanFromBlock,
 			toBlock: blockNumber
 		});
-		if (recoveredIds === null) throw new Error(`Could not recover an authoritative position list for vault ${vaultAddress$1} in pool ${poolInfo.pool} between blocks ${scanFromBlock} and ${blockNumber}`);
+		if (recoveredIds === null) throw new Error(`Could not recover an authoritative position list for vault ${vaultAddress$3} in pool ${poolInfo.pool} between blocks ${scanFromBlock} and ${blockNumber}`);
 		const candidates = sortBigintsAscending(new Set([...cachedIds, ...recoveredIds]));
 		return {
 			poolAddress: poolInfo.pool,
@@ -27615,16 +27813,16 @@ async function recoverVaultCandidateTokenIdsByPool({ viemClient, chainId, vaultA
 * vault instead of re-running the subgraph paging for every anchor block. The
 * combined {@link resolveVaultTokenIdsByPool} remains for one-shot callers.
 */
-async function resolveVaultHistoricalCandidatesByPool({ chainId, vaultAddress: vaultAddress$1, managerAddress, poolInfos, panopticSubgraphUrl, fetchFn = fetch }) {
-	const resolvedPoolInfos = poolInfos ?? getVaultPoolInfos(vaultAddress$1, chainId);
+async function resolveVaultHistoricalCandidatesByPool({ chainId, vaultAddress: vaultAddress$3, managerAddress: managerAddress$2, poolInfos, panopticSubgraphUrl, fetchFn = fetch }) {
+	const resolvedPoolInfos = poolInfos ?? getVaultPoolInfos(vaultAddress$3, chainId);
 	if (resolvedPoolInfos.length === 0) return [];
 	const configuredEndpoint = panopticSubgraphUrl ?? requireChainDeployment(chainId).subgraphs.panoptic;
 	if (configuredEndpoint === void 0) return resolvedPoolInfos.map((poolInfo) => ({
 		poolAddress: poolInfo.pool,
 		candidates: []
 	}));
-	const vaultAddressLower = toLowerAddress$1(vaultAddress$1);
-	const recipientAddresses = Array.from(new Set([vaultAddressLower, managerAddress?.toLowerCase()].filter((value) => value !== void 0 && value.length > 0).map((value) => value.toLowerCase())));
+	const vaultAddressLower = toLowerAddress$1(vaultAddress$3);
+	const recipientAddresses = Array.from(new Set([vaultAddressLower, managerAddress$2?.toLowerCase()].filter((value) => value !== void 0 && value.length > 0).map((value) => value.toLowerCase())));
 	const poolIds = Array.from(new Set(resolvedPoolInfos.map((poolInfo) => toLowerAddress$1(poolInfo.pool))));
 	const balanceCandidatesByPool = new Map();
 	const eventCandidatesByPool = new Map();
@@ -27658,13 +27856,13 @@ async function resolveVaultHistoricalCandidatesByPool({ chainId, vaultAddress: v
 * open at `blockNumber`, per pool, via on-chain `getFullPositionsData` (bisecting
 * on stale candidates). This is the per-block half of the candidate/verify split.
 */
-async function verifyVaultOpenTokenIdsAtBlock({ viemClient, vaultAddress: vaultAddress$1, candidatesByPool, blockNumber }) {
+async function verifyVaultOpenTokenIdsAtBlock({ viemClient, vaultAddress: vaultAddress$3, candidatesByPool, blockNumber }) {
 	const tokenIdsByPool = [];
 	for (const { poolAddress, candidates } of candidatesByPool) {
 		const openTokenIds = await filterOpenTokenIdsAtBlock({
 			viemClient,
 			poolAddress,
-			account: vaultAddress$1,
+			account: vaultAddress$3,
 			candidates,
 			blockNumber
 		});
@@ -27672,13 +27870,13 @@ async function verifyVaultOpenTokenIdsAtBlock({ viemClient, vaultAddress: vaultA
 	}
 	return tokenIdsByPool;
 }
-async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress: vaultAddress$1, managerAddress, poolInfos, panopticSubgraphUrl, verificationBlockNumber, fetchFn = fetch }) {
-	const resolvedPoolInfos = poolInfos ?? getVaultPoolInfos(vaultAddress$1, chainId);
+async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress: vaultAddress$3, managerAddress: managerAddress$2, poolInfos, panopticSubgraphUrl, verificationBlockNumber, fetchFn = fetch }) {
+	const resolvedPoolInfos = poolInfos ?? getVaultPoolInfos(vaultAddress$3, chainId);
 	if (resolvedPoolInfos.length === 0) return [];
 	const configuredEndpoint = panopticSubgraphUrl ?? requireChainDeployment(chainId).subgraphs.panoptic;
 	if (configuredEndpoint === void 0) return resolvedPoolInfos.map(() => []);
-	const vaultAddressLower = toLowerAddress$1(vaultAddress$1);
-	const recipientAddresses = Array.from(new Set([vaultAddressLower, managerAddress?.toLowerCase()].filter((value) => value !== void 0 && value.length > 0).map((value) => value.toLowerCase())));
+	const vaultAddressLower = toLowerAddress$1(vaultAddress$3);
+	const recipientAddresses = Array.from(new Set([vaultAddressLower, managerAddress$2?.toLowerCase()].filter((value) => value !== void 0 && value.length > 0).map((value) => value.toLowerCase())));
 	const poolIds = Array.from(new Set(resolvedPoolInfos.map((poolInfo) => toLowerAddress$1(poolInfo.pool))));
 	const balanceCandidatesByPool = new Map();
 	const eventCandidatesByPool = new Map();
@@ -27706,7 +27904,7 @@ async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress: v
 			const historicalOpenTokenIds = await filterOpenTokenIdsAtBlock({
 				viemClient,
 				poolAddress: poolInfo.pool,
-				account: vaultAddress$1,
+				account: vaultAddress$3,
 				candidates: historicalCandidates,
 				blockNumber: verificationBlockNumber
 			});
@@ -27728,7 +27926,7 @@ async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress: v
 				abi: panopticPoolV2Abi$1,
 				functionName: "getFullPositionsData",
 				args: [
-					vaultAddress$1,
+					vaultAddress$3,
 					false,
 					eventCandidates
 				],
@@ -27754,32 +27952,32 @@ async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress: v
 	}
 	return tokenIdsByPool;
 }
-async function buildVaultManagerInput({ viemClient, chainId, vaultAddress: vaultAddress$1, underlyingToken, managerAddress, panopticSubgraphUrl, fetchFn }) {
+async function buildVaultManagerInput({ viemClient, chainId, vaultAddress: vaultAddress$3, underlyingToken, managerAddress: managerAddress$2, panopticSubgraphUrl, fetchFn }) {
 	const blockNumber = await getBlockNumber(viemClient);
 	return buildVaultManagerInputAtBlock({
 		viemClient,
 		chainId,
-		vaultAddress: vaultAddress$1,
+		vaultAddress: vaultAddress$3,
 		underlyingToken,
 		blockNumber,
-		managerAddress,
+		managerAddress: managerAddress$2,
 		panopticSubgraphUrl,
 		fetchFn
 	});
 }
-async function buildVaultManagerInputAtBlock({ viemClient, chainId, vaultAddress: vaultAddress$1, underlyingToken, blockNumber, managerAddress, panopticSubgraphUrl, fetchFn }) {
+async function buildVaultManagerInputAtBlock({ viemClient, chainId, vaultAddress: vaultAddress$3, underlyingToken, blockNumber, managerAddress: managerAddress$2, panopticSubgraphUrl, fetchFn }) {
 	const poolInfos = await resolveVaultPoolInfosAtBlock({
 		viemClient,
 		chainId,
-		vaultAddress: vaultAddress$1,
+		vaultAddress: vaultAddress$3,
 		blockNumber
 	});
 	if (poolInfos.length === 0) return DEFAULT_MANAGER_INPUT$1;
 	const tokenIds = await resolveVaultTokenIdsByPool({
 		viemClient,
 		chainId,
-		vaultAddress: vaultAddress$1,
-		managerAddress,
+		vaultAddress: vaultAddress$3,
+		managerAddress: managerAddress$2,
 		poolInfos,
 		panopticSubgraphUrl,
 		verificationBlockNumber: blockNumber,
@@ -27812,10 +28010,10 @@ const erc20BalanceOfAbi = [{
 function toLowerAddress(address) {
 	return address.toLowerCase();
 }
-function discoverPoolAddresses$1({ chainId, vaultAddress: vaultAddress$1 }) {
+function discoverPoolAddresses$1({ chainId, vaultAddress: vaultAddress$3 }) {
 	const discoveredAddresses = [];
 	const seen = new Set();
-	const config = getHypoVaultConfigForVault(vaultAddress$1, chainId);
+	const config = getHypoVaultConfigForVault(vaultAddress$3, chainId);
 	const poolFromConfig = config?.addresses?.ethUsdc500bpsV4PanopticPool;
 	if (poolFromConfig !== void 0) {
 		const key = toLowerAddress(poolFromConfig);
@@ -27824,7 +28022,7 @@ function discoverPoolAddresses$1({ chainId, vaultAddress: vaultAddress$1 }) {
 			discoveredAddresses.push(poolFromConfig);
 		}
 	}
-	const artifactPoolInfos = getVaultPoolInfos(vaultAddress$1, chainId);
+	const artifactPoolInfos = getVaultPoolInfos(vaultAddress$3, chainId);
 	for (const poolInfo of artifactPoolInfos) {
 		const key = toLowerAddress(poolInfo.pool);
 		if (!seen.has(key)) {
@@ -27840,10 +28038,10 @@ function getUnderlyingIndex({ underlyingTokenAddress, token0Asset, token1Asset }
 	if (toLowerAddress(token1Asset) === underlyingLower) return 1;
 	return null;
 }
-async function getLendingAllocationRows({ client, chainId, vaultAddress: vaultAddress$1, underlyingTokenAddress, blockNumber }) {
+async function getLendingAllocationRows({ client, chainId, vaultAddress: vaultAddress$3, underlyingTokenAddress, blockNumber }) {
 	const poolAddresses = discoverPoolAddresses$1({
 		chainId,
-		vaultAddress: vaultAddress$1
+		vaultAddress: vaultAddress$3
 	});
 	const poolRows = await Promise.all(poolAddresses.map(async (poolAddress) => {
 		const metadata = await getPoolMetadata({
@@ -27864,7 +28062,7 @@ async function getLendingAllocationRows({ client, chainId, vaultAddress: vaultAd
 		}), getAccountCollateral({
 			client,
 			poolAddress,
-			account: vaultAddress$1,
+			account: vaultAddress$3,
 			blockNumber
 		})]);
 		const allocationUnderlying = underlyingIndex === 0 ? accountCollateral.token0.assets : accountCollateral.token1.assets;
@@ -27885,7 +28083,7 @@ async function getLendingAllocationRows({ client, chainId, vaultAddress: vaultAd
 		address: underlyingTokenAddress,
 		abi: erc20BalanceOfAbi,
 		functionName: "balanceOf",
-		args: [vaultAddress$1],
+		args: [vaultAddress$3],
 		blockNumber
 	});
 	const idleRow = {
@@ -27979,10 +28177,10 @@ function isNativeToken(tokenAddress) {
 function addressesEqual(a, b) {
 	return a.toLowerCase() === b.toLowerCase();
 }
-function discoverPoolAddresses({ chainId, vaultAddress: vaultAddress$1 }) {
+function discoverPoolAddresses({ chainId, vaultAddress: vaultAddress$3 }) {
 	const seen = new Set();
 	const addresses = [];
-	const config = getHypoVaultConfigForVault(vaultAddress$1, chainId);
+	const config = getHypoVaultConfigForVault(vaultAddress$3, chainId);
 	const configuredPool = config?.addresses?.ethUsdc500bpsV4PanopticPool;
 	if (configuredPool !== void 0) {
 		const key = configuredPool.toLowerCase();
@@ -27991,7 +28189,7 @@ function discoverPoolAddresses({ chainId, vaultAddress: vaultAddress$1 }) {
 			addresses.push(configuredPool);
 		}
 	}
-	const artifactInfos = getVaultPoolInfos(vaultAddress$1, chainId);
+	const artifactInfos = getVaultPoolInfos(vaultAddress$3, chainId);
 	for (const info of artifactInfos) {
 		const key = info.pool.toLowerCase();
 		if (!seen.has(key)) {
@@ -28151,10 +28349,10 @@ function calculateVaultNetLendingYieldUnderlyingFromTrackerInputs({ inputs, inte
 	}
 	return sawAssets ? totalNetYieldUnderlying : null;
 }
-async function fetchVaultNetLendingApyPct({ client, chainId, vaultAddress: vaultAddress$1, underlyingTokenAddress, blockNumber }) {
+async function fetchVaultNetLendingApyPct({ client, chainId, vaultAddress: vaultAddress$3, underlyingTokenAddress, blockNumber }) {
 	const poolAddresses = discoverPoolAddresses({
 		chainId,
-		vaultAddress: vaultAddress$1
+		vaultAddress: vaultAddress$3
 	});
 	if (poolAddresses.length === 0) return null;
 	const poolContexts = await Promise.all(poolAddresses.map(async (poolAddress) => {
@@ -28214,14 +28412,14 @@ async function fetchVaultNetLendingApyPct({ client, chainId, vaultAddress: vault
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "assetsOf",
-				args: [vaultAddress$1],
+				args: [vaultAddress$3],
 				...blockNumber === void 0 ? {} : { blockNumber }
 			}),
 			client.readContract({
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "interestState",
-				args: [vaultAddress$1],
+				args: [vaultAddress$3],
 				...blockNumber === void 0 ? {} : { blockNumber }
 			}),
 			client.readContract({
@@ -28246,10 +28444,10 @@ async function fetchVaultNetLendingApyPct({ client, chainId, vaultAddress: vault
 	})));
 	return calculateVaultNetLendingApyPctFromTrackerInputs(trackerInputs.filter((input) => input !== null));
 }
-async function fetchVaultNetLendingYieldUnderlying({ client, chainId, vaultAddress: vaultAddress$1, underlyingTokenAddress, blockNumber, intervalSeconds }) {
+async function fetchVaultNetLendingYieldUnderlying({ client, chainId, vaultAddress: vaultAddress$3, underlyingTokenAddress, blockNumber, intervalSeconds }) {
 	const poolAddresses = discoverPoolAddresses({
 		chainId,
-		vaultAddress: vaultAddress$1
+		vaultAddress: vaultAddress$3
 	});
 	if (poolAddresses.length === 0) return null;
 	const poolContexts = await Promise.all(poolAddresses.map(async (poolAddress) => {
@@ -28309,14 +28507,14 @@ async function fetchVaultNetLendingYieldUnderlying({ client, chainId, vaultAddre
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "assetsOf",
-				args: [vaultAddress$1],
+				args: [vaultAddress$3],
 				blockNumber
 			}),
 			client.readContract({
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "interestState",
-				args: [vaultAddress$1],
+				args: [vaultAddress$3],
 				blockNumber
 			}),
 			client.readContract({
@@ -28344,14 +28542,14 @@ async function fetchVaultNetLendingYieldUnderlying({ client, chainId, vaultAddre
 		intervalSeconds
 	});
 }
-async function fetchVaultLendingAllocation({ client, chainId, vaultAddress: vaultAddress$1, underlyingTokenAddress, blockNumber }) {
+async function fetchVaultLendingAllocation({ client, chainId, vaultAddress: vaultAddress$3, underlyingTokenAddress, blockNumber }) {
 	const [reservedWithdrawalAssetsRaw, depositEpochRaw] = await Promise.all([client.readContract({
-		address: vaultAddress$1,
+		address: vaultAddress$3,
 		abi: HypoVaultAbi,
 		functionName: "reservedWithdrawalAssets",
 		...blockNumber === void 0 ? {} : { blockNumber }
 	}), client.readContract({
-		address: vaultAddress$1,
+		address: vaultAddress$3,
 		abi: HypoVaultAbi,
 		functionName: "depositEpoch",
 		...blockNumber === void 0 ? {} : { blockNumber }
@@ -28359,7 +28557,7 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress: vaul
 	const reservedWithdrawalAssets = toBigInt$1(reservedWithdrawalAssetsRaw) ?? 0n;
 	const depositEpoch = toBigInt$1(depositEpochRaw);
 	const depositEpochStateRaw = depositEpoch === null ? null : await client.readContract({
-		address: vaultAddress$1,
+		address: vaultAddress$3,
 		abi: HypoVaultAbi,
 		functionName: "depositEpochState",
 		args: [depositEpoch],
@@ -28368,7 +28566,7 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress: vaul
 	const unfulfilledDepositAssets = depositEpochStateRaw === null ? 0n : getAssetsDepositedFromDepositEpochState$1(depositEpochStateRaw);
 	const poolAddresses = discoverPoolAddresses({
 		chainId,
-		vaultAddress: vaultAddress$1
+		vaultAddress: vaultAddress$3
 	});
 	const poolContexts = await Promise.all(poolAddresses.map(async (poolAddress) => {
 		const [collateral0Address, collateral1Address] = await Promise.all([client.readContract({
@@ -28449,7 +28647,7 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress: vaul
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "assetsOf",
-				args: [vaultAddress$1],
+				args: [vaultAddress$3],
 				...blockNumber === void 0 ? {} : { blockNumber }
 			}),
 			client.readContract({
@@ -28524,7 +28722,7 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress: vaul
 		const balance = await readTokenBalance({
 			client,
 			tokenAddress: address,
-			owner: vaultAddress$1,
+			owner: vaultAddress$3,
 			blockNumber
 		});
 		const adjustedBalance = addressesEqual(address, underlyingTokenAddress) ? adjustUnderlyingIdleBalance({
@@ -28614,8 +28812,8 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress: vaul
 
 //#endregion
 //#region src/hypoVault/cancelDeposit/cancelDeposit.ts
-const getCancelDepositContractConfig = ({ vaultAddress: vaultAddress$1 }) => ({
-	address: vaultAddress$1,
+const getCancelDepositContractConfig = ({ vaultAddress: vaultAddress$3 }) => ({
+	address: vaultAddress$3,
 	abi: HypoVaultAbi,
 	functionName: "cancelDeposit",
 	args: []
@@ -28627,15 +28825,15 @@ function encodeCancelDepositFunctionData() {
 		args: []
 	});
 }
-function simulateCancelDeposit({ viemClient, vaultAddress: vaultAddress$1, account }) {
+function simulateCancelDeposit({ viemClient, vaultAddress: vaultAddress$3, account }) {
 	return simulateContract(viemClient, {
-		...getCancelDepositContractConfig({ vaultAddress: vaultAddress$1 }),
+		...getCancelDepositContractConfig({ vaultAddress: vaultAddress$3 }),
 		account
 	});
 }
-function cancelDeposit({ walletClient, vaultAddress: vaultAddress$1, account }) {
+function cancelDeposit({ walletClient, vaultAddress: vaultAddress$3, account }) {
 	return writeContract(walletClient, {
-		...getCancelDepositContractConfig({ vaultAddress: vaultAddress$1 }),
+		...getCancelDepositContractConfig({ vaultAddress: vaultAddress$3 }),
 		account
 	});
 }
@@ -28672,12 +28870,12 @@ const isErrorUserRejection = (errorMessage) => errorMessage.includes("User rejec
 
 //#endregion
 //#region src/hypoVault/cancelDeposit/hooks/use-cancel-deposit.ts
-const useCancelDeposit = ({ chainId, vaultAddress: vaultAddress$1, onWaitSuccess }) => {
+const useCancelDeposit = ({ chainId, vaultAddress: vaultAddress$3, onWaitSuccess }) => {
 	const { address: account } = useAccount();
-	const canSimulate = vaultAddress$1 !== zeroAddress && account != null && account !== zeroAddress;
+	const canSimulate = vaultAddress$3 !== zeroAddress && account != null && account !== zeroAddress;
 	const simulate = useSimulateContract({
 		chainId,
-		...getCancelDepositContractConfig({ vaultAddress: vaultAddress$1 }),
+		...getCancelDepositContractConfig({ vaultAddress: vaultAddress$3 }),
 		account,
 		query: {
 			enabled: canSimulate,
@@ -28753,51 +28951,51 @@ function encodeExecuteWithdrawalMulticallFunctionData({ multicallCalldatas }) {
 		args: [multicallCalldatas]
 	});
 }
-const getExecuteWithdrawalContractConfig = ({ vaultAddress: vaultAddress$1, user, epoch }) => ({
-	address: vaultAddress$1,
+const getExecuteWithdrawalContractConfig = ({ vaultAddress: vaultAddress$3, user, epoch }) => ({
+	address: vaultAddress$3,
 	abi: HypoVaultAbi,
 	functionName: "executeWithdrawal",
 	args: [user, epoch]
 });
-const getExecuteWithdrawalMulticallContractConfig = ({ vaultAddress: vaultAddress$1, multicallCalldatas }) => ({
-	address: vaultAddress$1,
+const getExecuteWithdrawalMulticallContractConfig = ({ vaultAddress: vaultAddress$3, multicallCalldatas }) => ({
+	address: vaultAddress$3,
 	abi: HypoVaultAbi,
 	functionName: "multicall",
 	args: [multicallCalldatas]
 });
-function simulateExecuteWithdrawal({ viemClient, vaultAddress: vaultAddress$1, user, epoch, account }) {
+function simulateExecuteWithdrawal({ viemClient, vaultAddress: vaultAddress$3, user, epoch, account }) {
 	return simulateContract(viemClient, {
 		...getExecuteWithdrawalContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			user,
 			epoch
 		}),
 		account
 	});
 }
-function executeWithdrawal({ walletClient, vaultAddress: vaultAddress$1, user, epoch, account }) {
+function executeWithdrawal({ walletClient, vaultAddress: vaultAddress$3, user, epoch, account }) {
 	return writeContract(walletClient, {
 		...getExecuteWithdrawalContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			user,
 			epoch
 		}),
 		account
 	});
 }
-function simulateExecuteWithdrawalMulticall({ viemClient, vaultAddress: vaultAddress$1, multicallCalldatas, account }) {
+function simulateExecuteWithdrawalMulticall({ viemClient, vaultAddress: vaultAddress$3, multicallCalldatas, account }) {
 	return simulateContract(viemClient, {
 		...getExecuteWithdrawalMulticallContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			multicallCalldatas
 		}),
 		account
 	});
 }
-function executeWithdrawalMulticall({ walletClient, vaultAddress: vaultAddress$1, multicallCalldatas, account }) {
+function executeWithdrawalMulticall({ walletClient, vaultAddress: vaultAddress$3, multicallCalldatas, account }) {
 	return writeContract(walletClient, {
 		...getExecuteWithdrawalMulticallContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			multicallCalldatas
 		}),
 		account
@@ -28877,7 +29075,7 @@ const selectExecutableWithdrawalEpochs = ({ desiredAssets, maxAssetsToExecute, c
 		assetsToExecute: accumulatedAssets
 	};
 };
-const useExecuteWithdrawal = ({ chainId, vaultAddress: vaultAddress$1, desiredAssets, maxAssetsToExecute, queuedWithdrawals, withdrawalEpochStates, currentWithdrawalEpoch, simulationAccount, onWaitSuccess }) => {
+const useExecuteWithdrawal = ({ chainId, vaultAddress: vaultAddress$3, desiredAssets, maxAssetsToExecute, queuedWithdrawals, withdrawalEpochStates, currentWithdrawalEpoch, simulationAccount, onWaitSuccess }) => {
 	const { address: account } = useAccount();
 	const simulatedAccount = simulationAccount ?? account;
 	const user = simulatedAccount ?? zeroAddress;
@@ -28921,11 +29119,11 @@ const useExecuteWithdrawal = ({ chainId, vaultAddress: vaultAddress$1, desiredAs
 		assetsToExecute,
 		claimableAssets: claimableWithdrawals.totalAssets
 	});
-	const canSimulate = multicallCalldatas.length > 0 && vaultAddress$1 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
+	const canSimulate = multicallCalldatas.length > 0 && vaultAddress$3 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
 	const simulate = useSimulateContract({
 		chainId,
 		...getExecuteWithdrawalMulticallContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			multicallCalldatas
 		}),
 		account: simulatedAccount,
@@ -28992,6 +29190,23 @@ const useExecuteWithdrawal = ({ chainId, vaultAddress: vaultAddress$1, desiredAs
 	};
 };
 
+//#endregion
+//#region src/hypoVault/hooks/use-erc20-balance.ts
+function useErc20Balance({ chainId, token, account, enabled = true, staleTime }) {
+	return useReadContract({
+		chainId,
+		address: token,
+		abi: Erc20Abi,
+		functionName: "balanceOf",
+		args: [account],
+		query: {
+			enabled,
+			staleTime,
+			refetchOnWindowFocus: false
+		}
+	});
+}
+
 //#endregion
 //#region src/hypoVault/hypoVaultManagerArtifacts/BaseUSDCPLPStrategistLeaves.ts
 const BaseUSDCPLPStrategistLeaves = {
@@ -30076,8 +30291,8 @@ function encodeFulfillWithdrawalsFunctionData({ sharesToFulfill, maxAssetsReceiv
 
 //#endregion
 //#region src/hypoVault/requestDeposit/requestDeposit.ts
-const getRequestDepositContractConfig = ({ vaultAddress: vaultAddress$1, assets }) => ({
-	address: vaultAddress$1,
+const getRequestDepositContractConfig = ({ vaultAddress: vaultAddress$3, assets }) => ({
+	address: vaultAddress$3,
 	abi: HypoVaultAbi,
 	functionName: "requestDeposit",
 	args: [assets]
@@ -30089,19 +30304,19 @@ function encodeRequestDepositFunctionData({ assets }) {
 		args: [assets]
 	});
 }
-function simulateRequestDeposit({ viemClient, vaultAddress: vaultAddress$1, assets, account }) {
+function simulateRequestDeposit({ viemClient, vaultAddress: vaultAddress$3, assets, account }) {
 	return simulateContract(viemClient, {
 		...getRequestDepositContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			assets
 		}),
 		account
 	});
 }
-function requestDeposit({ walletClient, vaultAddress: vaultAddress$1, assets, account }) {
+function requestDeposit({ walletClient, vaultAddress: vaultAddress$3, assets, account }) {
 	return writeContract(walletClient, {
 		...getRequestDepositContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			assets
 		}),
 		account
@@ -30112,16 +30327,16 @@ function requestDeposit({ walletClient, vaultAddress: vaultAddress$1, assets, ac
 //#region src/hypoVault/requestDeposit/hooks/use-request-deposit.ts
 const APPROVAL_SYNC_POLL_INTERVAL_MS = 1200;
 const APPROVAL_SYNC_MAX_ATTEMPTS = 20;
-const useRequestDeposit = ({ chainId, vaultAddress: vaultAddress$1, assets, tokenAddress, simulationAccount, onWaitSuccess }) => {
+const useRequestDeposit = ({ chainId, vaultAddress: vaultAddress$3, assets, tokenAddress, simulationAccount, onWaitSuccess }) => {
 	const { address: account } = useAccount();
 	const simulatedAccount = simulationAccount ?? account;
-	const canReadAllowance = simulatedAccount != null && simulatedAccount !== zeroAddress && tokenAddress !== zeroAddress && vaultAddress$1 !== zeroAddress;
+	const canReadAllowance = simulatedAccount != null && simulatedAccount !== zeroAddress && tokenAddress !== zeroAddress && vaultAddress$3 !== zeroAddress;
 	const allowanceRead = useReadContract({
 		chainId,
 		address: canReadAllowance ? tokenAddress : void 0,
 		abi: Erc20Abi,
 		functionName: "allowance",
-		args: canReadAllowance ? [simulatedAccount, vaultAddress$1] : void 0,
+		args: canReadAllowance ? [simulatedAccount, vaultAddress$3] : void 0,
 		query: { enabled: canReadAllowance }
 	});
 	const allowanceKnown = allowanceRead.data !== void 0;
@@ -30135,7 +30350,7 @@ const useRequestDeposit = ({ chainId, vaultAddress: vaultAddress$1, assets, toke
 		address: tokenAddress,
 		abi: Erc20Abi,
 		functionName: "approve",
-		args: [vaultAddress$1, maxUint256],
+		args: [vaultAddress$3, maxUint256],
 		account,
 		query: {
 			enabled: allowanceKnown && tokenNeedsApproval && assets > 0n && account != null && canApproveForSimulatedAccount,
@@ -30154,12 +30369,12 @@ const useRequestDeposit = ({ chainId, vaultAddress: vaultAddress$1, assets, toke
 	const simulate = useSimulateContract({
 		chainId,
 		...getRequestDepositContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			assets
 		}),
 		account: simulatedAccount,
 		query: {
-			enabled: allowanceKnown && !tokenNeedsApproval && assets > 0n && vaultAddress$1 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress,
+			enabled: allowanceKnown && !tokenNeedsApproval && assets > 0n && vaultAddress$3 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress,
 			retry: false
 		}
 	});
@@ -30418,49 +30633,49 @@ function encodeRequestWithdrawalMulticallFunctionData({ multicallCalldatas }) {
 		args: [multicallCalldatas]
 	});
 }
-const getRequestWithdrawalContractConfig = ({ vaultAddress: vaultAddress$1, shares }) => ({
-	address: vaultAddress$1,
+const getRequestWithdrawalContractConfig = ({ vaultAddress: vaultAddress$3, shares }) => ({
+	address: vaultAddress$3,
 	abi: HypoVaultAbi,
 	functionName: "requestWithdrawal",
 	args: [shares]
 });
-const getRequestWithdrawalMulticallContractConfig = ({ vaultAddress: vaultAddress$1, multicallCalldatas }) => ({
-	address: vaultAddress$1,
+const getRequestWithdrawalMulticallContractConfig = ({ vaultAddress: vaultAddress$3, multicallCalldatas }) => ({
+	address: vaultAddress$3,
 	abi: HypoVaultAbi,
 	functionName: "multicall",
 	args: [multicallCalldatas]
 });
-function simulateRequestWithdrawal({ viemClient, vaultAddress: vaultAddress$1, shares, account }) {
+function simulateRequestWithdrawal({ viemClient, vaultAddress: vaultAddress$3, shares, account }) {
 	return simulateContract(viemClient, {
 		...getRequestWithdrawalContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			shares
 		}),
 		account
 	});
 }
-function requestWithdrawal({ walletClient, vaultAddress: vaultAddress$1, shares, account }) {
+function requestWithdrawal({ walletClient, vaultAddress: vaultAddress$3, shares, account }) {
 	return writeContract(walletClient, {
 		...getRequestWithdrawalContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			shares
 		}),
 		account
 	});
 }
-function simulateRequestWithdrawalMulticall({ viemClient, vaultAddress: vaultAddress$1, multicallCalldatas, account }) {
+function simulateRequestWithdrawalMulticall({ viemClient, vaultAddress: vaultAddress$3, multicallCalldatas, account }) {
 	return simulateContract(viemClient, {
 		...getRequestWithdrawalMulticallContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			multicallCalldatas
 		}),
 		account
 	});
 }
-function requestWithdrawalMulticall({ walletClient, vaultAddress: vaultAddress$1, multicallCalldatas, account }) {
+function requestWithdrawalMulticall({ walletClient, vaultAddress: vaultAddress$3, multicallCalldatas, account }) {
 	return writeContract(walletClient, {
 		...getRequestWithdrawalMulticallContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			multicallCalldatas
 		}),
 		account
@@ -30531,7 +30746,7 @@ function buildRequestWithdrawalCalldatas({ user, desiredAssets, requestAllAvaila
 
 //#endregion
 //#region src/hypoVault/requestWithdrawal/hooks/use-claim-vault-shares.ts
-const useClaimVaultShares = ({ chainId, vaultAddress: vaultAddress$1, queuedDeposits, depositEpochStates, currentDepositEpoch, simulationAccount, onWaitSuccess }) => {
+const useClaimVaultShares = ({ chainId, vaultAddress: vaultAddress$3, queuedDeposits, depositEpochStates, currentDepositEpoch, simulationAccount, onWaitSuccess }) => {
 	const { address: account } = useAccount();
 	const simulatedAccount = simulationAccount ?? account;
 	const user = simulatedAccount ?? zeroAddress;
@@ -30546,11 +30761,11 @@ const useClaimVaultShares = ({ chainId, vaultAddress: vaultAddress$1, queuedDepo
 		depositEpochStates,
 		currentDepositEpoch
 	]);
-	const canSimulate = multicallCalldatas.length > 0 && vaultAddress$1 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
+	const canSimulate = multicallCalldatas.length > 0 && vaultAddress$3 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
 	const simulate = useSimulateContract({
 		chainId,
 		...getRequestWithdrawalMulticallContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			multicallCalldatas
 		}),
 		account: simulatedAccount,
@@ -30623,7 +30838,7 @@ const useClaimVaultShares = ({ chainId, vaultAddress: vaultAddress$1, queuedDepo
 
 //#endregion
 //#region src/hypoVault/requestWithdrawal/hooks/use-request-withdrawal.ts
-const useRequestWithdrawal = ({ chainId, vaultAddress: vaultAddress$1, desiredAssets, requestAllAvailableShares = false, sharePrice, walletShares, queuedDeposits, depositEpochStates, currentDepositEpoch, simulationAccount, onWaitSuccess }) => {
+const useRequestWithdrawal = ({ chainId, vaultAddress: vaultAddress$3, desiredAssets, requestAllAvailableShares = false, sharePrice, walletShares, queuedDeposits, depositEpochStates, currentDepositEpoch, simulationAccount, onWaitSuccess }) => {
 	const { address: account } = useAccount();
 	const simulatedAccount = simulationAccount ?? account;
 	const user = simulatedAccount ?? zeroAddress;
@@ -30646,11 +30861,11 @@ const useRequestWithdrawal = ({ chainId, vaultAddress: vaultAddress$1, desiredAs
 		depositEpochStates,
 		currentDepositEpoch
 	]);
-	const canSimulate = multicallCalldatas.length > 0 && vaultAddress$1 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
+	const canSimulate = multicallCalldatas.length > 0 && vaultAddress$3 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
 	const simulate = useSimulateContract({
 		chainId,
 		...getRequestWithdrawalMulticallContractConfig({
-			vaultAddress: vaultAddress$1,
+			vaultAddress: vaultAddress$3,
 			multicallCalldatas
 		}),
 		account: simulatedAccount,
@@ -31174,7 +31389,7 @@ function getSdk(client, withWrapper = defaultWrapper) {
 //#endregion
 //#region src/graphqlClient.ts
 const chainToHypoVaultGraphQlAPI = {};
-for (const deployment$2 of Object.values(CHAIN_DEPLOYMENTS)) chainToHypoVaultGraphQlAPI[deployment$2.chainId] = deployment$2.subgraphs.hypovault;
+for (const deployment$3 of Object.values(CHAIN_DEPLOYMENTS)) chainToHypoVaultGraphQlAPI[deployment$3.chainId] = deployment$3.subgraphs.hypovault;
 function getHypoVaultGraphQLClient(chainId) {
 	const apiUrl = chainToHypoVaultGraphQlAPI[chainId];
 	if (apiUrl === void 0) throw new Error(`Unsupported HypoVault subgraph chainId: ${chainId}`);
@@ -31188,7 +31403,7 @@ function parseTimestampSec(value) {
 	const parsed = Number(value);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
-async function fetchFirstDepositTimestampForVault({ graphClient, vaultAddress: vaultAddress$1 }) {
+async function fetchFirstDepositTimestampForVault({ graphClient, vaultAddress: vaultAddress$3 }) {
 	const response = await graphClient.request(`
       query FirstVaultDepositTimestamp($hypoVault: String!) {
         depositExecuteds(
@@ -31222,7 +31437,7 @@ async function fetchFirstDepositTimestampForVault({ graphClient, vaultAddress: v
           }
         }
       }
-    `, { hypoVault: vaultAddress$1.toLowerCase() });
+    `, { hypoVault: vaultAddress$3.toLowerCase() });
 	const timestamps = [...response.depositExecuteds, ...response.depositsFulfilleds].map((event) => parseTimestampSec(event.blockTimestamp)).filter((timestamp) => timestamp !== null);
 	if (timestamps.length === 0) return null;
 	return Math.min(...timestamps);
@@ -31231,8 +31446,8 @@ async function fetchFirstDepositTimestampByVaultId({ chainId, vaultAddresses })
 	const endpoint = chainToHypoVaultGraphQlAPI[chainId];
 	if (endpoint === void 0 || vaultAddresses.length === 0) return {};
 	const graphClient = new GraphQLClient(endpoint);
-	const entries = await Promise.all(vaultAddresses.map(async (vaultAddress$1) => {
-		const vaultAddressLower = vaultAddress$1.toLowerCase();
+	const entries = await Promise.all(vaultAddresses.map(async (vaultAddress$3) => {
+		const vaultAddressLower = vaultAddress$3.toLowerCase();
 		const timestamp = await fetchFirstDepositTimestampForVault({
 			graphClient,
 			vaultAddress: vaultAddressLower
@@ -31354,27 +31569,27 @@ function getStaleOracleStateOverrideForAccountant(accountantAddress) {
 //#endregion
 //#region src/hypoVault/sharePrice/strategies.ts
 const DEFAULT_MANAGER_INPUT = "0x";
-function buildVaultStrategyKey(chainId, vaultAddress$1) {
-	return `${chainId}:${vaultAddress$1.toLowerCase()}`;
+function buildVaultStrategyKey(chainId, vaultAddress$3) {
+	return `${chainId}:${vaultAddress$3.toLowerCase()}`;
 }
 function resolveChainWethAddress(chainId) {
-	let deployment$2;
+	let deployment$3;
 	try {
-		deployment$2 = requireChainDeployment(chainId);
+		deployment$3 = requireChainDeployment(chainId);
 	} catch {
 		return void 0;
 	}
-	const wethVaultAddress = deployment$2.hypovault.vaults.wethPlpVault;
+	const wethVaultAddress = deployment$3.hypovault.vaults.wethPlpVault;
 	return getHypoVaultConfigForVault(wethVaultAddress, chainId)?.addresses?.underlyingToken;
 }
-function getPlpManagerAddress(chainId, vaultAddress$1) {
-	return getHypoVaultConfigForVault(vaultAddress$1, chainId)?.addresses?.hypoVaultManagerWithMerkleVerification ?? null;
+function getPlpManagerAddress(chainId, vaultAddress$3) {
+	return getHypoVaultConfigForVault(vaultAddress$3, chainId)?.addresses?.hypoVaultManagerWithMerkleVerification ?? null;
 }
-async function getPlpPoolInfosAtBlock({ chainId, client, vaultAddress: vaultAddress$1, blockNumber }) {
+async function getPlpPoolInfosAtBlock({ chainId, client, vaultAddress: vaultAddress$3, blockNumber }) {
 	return resolveVaultPoolInfosAtBlock({
 		viemClient: client,
 		chainId,
-		vaultAddress: vaultAddress$1,
+		vaultAddress: vaultAddress$3,
 		blockNumber
 	});
 }
@@ -31382,27 +31597,27 @@ function createPlpManagerInputStrategy(minBlock) {
 	return {
 		enabledMetrics: ["nav"],
 		resolveCandidates: async ({ chainId, vault: vault$2 }) => {
-			const vaultAddress$1 = vault$2.id;
-			const poolInfos = getVaultCandidatePoolInfos(vaultAddress$1, chainId);
+			const vaultAddress$3 = vault$2.id;
+			const poolInfos = getVaultCandidatePoolInfos(vaultAddress$3, chainId);
 			if (poolInfos.length === 0) return [];
 			return resolveVaultHistoricalCandidatesByPool({
 				chainId,
-				vaultAddress: vaultAddress$1,
-				managerAddress: getPlpManagerAddress(chainId, vaultAddress$1),
+				vaultAddress: vaultAddress$3,
+				managerAddress: getPlpManagerAddress(chainId, vaultAddress$3),
 				poolInfos
 			});
 		},
 		recoverCandidates: async ({ chainId, client, vault: vault$2, blockNumber, fromBlock, candidates }) => {
-			const vaultAddress$1 = vault$2.id;
+			const vaultAddress$3 = vault$2.id;
 			return recoverVaultCandidateTokenIdsByPool({
 				viemClient: client,
 				chainId,
-				vaultAddress: vaultAddress$1,
+				vaultAddress: vaultAddress$3,
 				candidatesByPool: candidates,
 				poolInfos: await getPlpPoolInfosAtBlock({
 					chainId,
 					client,
-					vaultAddress: vaultAddress$1,
+					vaultAddress: vaultAddress$3,
 					blockNumber
 				}),
 				blockNumber,
@@ -31410,7 +31625,7 @@ function createPlpManagerInputStrategy(minBlock) {
 			});
 		},
 		managerInputProvider: async ({ chainId, client, vault: vault$2, blockNumber, candidates }) => {
-			const vaultAddress$1 = vault$2.id;
+			const vaultAddress$3 = vault$2.id;
 			if (minBlock !== void 0 && blockNumber < minBlock) throw new VaultApyPreInceptionBlockError({
 				blockNumber,
 				minBlockNumber: minBlock,
@@ -31419,20 +31634,20 @@ function createPlpManagerInputStrategy(minBlock) {
 			const poolInfos = await getPlpPoolInfosAtBlock({
 				chainId,
 				client,
-				vaultAddress: vaultAddress$1,
+				vaultAddress: vaultAddress$3,
 				blockNumber
 			});
 			if (poolInfos.length === 0) return DEFAULT_MANAGER_INPUT;
 			const tokenIds = candidates === void 0 ? await resolveVaultTokenIdsByPool({
 				viemClient: client,
 				chainId,
-				vaultAddress: vaultAddress$1,
-				managerAddress: getPlpManagerAddress(chainId, vaultAddress$1),
+				vaultAddress: vaultAddress$3,
+				managerAddress: getPlpManagerAddress(chainId, vaultAddress$3),
 				poolInfos,
 				verificationBlockNumber: blockNumber
 			}) : await verifyVaultOpenTokenIdsAtBlock({
 				viemClient: client,
-				vaultAddress: vaultAddress$1,
+				vaultAddress: vaultAddress$3,
 				candidatesByPool: poolInfos.map((poolInfo) => {
 					const candidate = candidates.find((item) => item.poolAddress.toLowerCase() === poolInfo.pool.toLowerCase());
 					if (candidate === void 0) throw new Error(`Missing token-id candidates for authorized pool ${poolInfo.pool}`);
@@ -31476,16 +31691,16 @@ const strategyOverridesByVaultKey = {
 	[buildVaultStrategyKey(SEPOLIA_CHAIN_ID, SepoliaUSDCPLPVaultPoolInfos.vaultAddress)]: createPlpManagerInputStrategy(SEPOLIA_PLP_POOL_MIN_BLOCK),
 	[buildVaultStrategyKey(SEPOLIA_CHAIN_ID, SepoliaWETHPLPVaultPoolInfos.vaultAddress)]: createPlpManagerInputStrategy(SEPOLIA_PLP_POOL_MIN_BLOCK)
 };
-function getVaultApyStrategy({ chainId, vaultAddress: vaultAddress$1 }) {
-	const key = buildVaultStrategyKey(chainId, vaultAddress$1);
+function getVaultApyStrategy({ chainId, vaultAddress: vaultAddress$3 }) {
+	const key = buildVaultStrategyKey(chainId, vaultAddress$3);
 	return strategyOverridesByVaultKey[key] ?? defaultStrategy;
 }
-function setVaultApyStrategyOverride({ chainId, vaultAddress: vaultAddress$1, strategy }) {
-	const key = buildVaultStrategyKey(chainId, vaultAddress$1);
+function setVaultApyStrategyOverride({ chainId, vaultAddress: vaultAddress$3, strategy }) {
+	const key = buildVaultStrategyKey(chainId, vaultAddress$3);
 	strategyOverridesByVaultKey[key] = strategy;
 }
-function clearVaultApyStrategyOverride({ chainId, vaultAddress: vaultAddress$1 }) {
-	const key = buildVaultStrategyKey(chainId, vaultAddress$1);
+function clearVaultApyStrategyOverride({ chainId, vaultAddress: vaultAddress$3 }) {
+	const key = buildVaultStrategyKey(chainId, vaultAddress$3);
 	delete strategyOverridesByVaultKey[key];
 }
 
@@ -31505,12 +31720,12 @@ function getAssetsDepositedFromDepositEpochState(value) {
 	return null;
 }
 async function fetchVaultSharePriceSnapshot({ client, vault: vault$2, chainId, windowLabel, blockNumber, readContractFn, candidates, includeTokenIdsInDiagnostics = false }) {
-	const vaultAddress$1 = vault$2.id;
+	const vaultAddress$3 = vault$2.id;
 	const accountantAddress = vault$2.accountant;
 	const underlyingTokenAddress = vault$2.underlyingToken.id;
 	const strategy = getVaultApyStrategy({
 		chainId,
-		vaultAddress: vaultAddress$1
+		vaultAddress: vaultAddress$3
 	});
 	const managerInputProviderResult = await strategy.managerInputProvider({
 		chainId,
@@ -31542,7 +31757,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault: vault$2, chainId, w
 		readWithContext({
 			callName: "depositEpoch",
 			request: {
-				address: vaultAddress$1,
+				address: vaultAddress$3,
 				abi: HypoVaultAbi,
 				functionName: "depositEpoch",
 				blockNumber
@@ -31551,7 +31766,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault: vault$2, chainId, w
 		readWithContext({
 			callName: "reservedWithdrawalAssets",
 			request: {
-				address: vaultAddress$1,
+				address: vaultAddress$3,
 				abi: HypoVaultAbi,
 				functionName: "reservedWithdrawalAssets",
 				blockNumber
@@ -31560,7 +31775,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault: vault$2, chainId, w
 		readWithContext({
 			callName: "totalSupply",
 			request: {
-				address: vaultAddress$1,
+				address: vaultAddress$3,
 				abi: HypoVaultAbi,
 				functionName: "totalSupply",
 				blockNumber
@@ -31572,7 +31787,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault: vault$2, chainId, w
 	const depositEpochStateRaw = await readWithContext({
 		callName: "depositEpochState",
 		request: {
-			address: vaultAddress$1,
+			address: vaultAddress$3,
 			abi: HypoVaultAbi,
 			functionName: "depositEpochState",
 			args: [depositEpoch],
@@ -31591,7 +31806,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault: vault$2, chainId, w
 		abi: PanopticVaultAccountantAbi,
 		functionName: "computeNAV",
 		args: [
-			vaultAddress$1,
+			vaultAddress$3,
 			underlyingTokenAddress,
 			managerInput
 		],
@@ -31749,12 +31964,12 @@ function deriveVaultApyTimeseriesFromSharePrices(sharePricePoints) {
 	const sorted = [...sharePricePoints].sort((a, b) => a.timestampSec - b.timestampSec);
 	const points = [];
 	for (let i = 1; i < sorted.length; i += 1) {
-		const previous = sorted[i - 1];
+		const previous$1 = sorted[i - 1];
 		const current = sorted[i];
-		const days = (current.timestampSec - previous.timestampSec) / SECONDS_PER_DAY$1;
+		const days = (current.timestampSec - previous$1.timestampSec) / SECONDS_PER_DAY$1;
 		const apyPct = calculateAnnualizedApyPct({
 			currentSharePrice: new Decimal(current.sharePrice),
-			previousSharePrice: new Decimal(previous.sharePrice),
+			previousSharePrice: new Decimal(previous$1.sharePrice),
 			days
 		});
 		if (apyPct === null || !Number.isFinite(apyPct)) continue;
@@ -31854,6 +32069,7 @@ function resolveFeeHistoryQuote({ baseFeePerGas, reward, minimumPriorityFeePerGa
 	const maxPriorityFeePerGas = clampPriorityFee(sampledPriorityFee, effectivePriorityFeeFloor);
 	const bufferedBaseFee = ceilMultiplyFraction(baseFeePerGas[latestBaseFeeIndex], BASE_FEE_BUFFER_NUMERATOR, BASE_FEE_BUFFER_DENOMINATOR);
 	return {
+		currentBaseFeePerGas: baseFeePerGas[latestBaseFeeIndex],
 		maxFeePerGas: bufferedBaseFee + maxPriorityFeePerGas,
 		maxPriorityFeePerGas,
 		minimumMaxFeePerGas: bufferedBaseFee + effectivePriorityFeeFloor,
@@ -31988,11 +32204,15 @@ function validateVaultSignedTransactionFeeCaps(feeCaps, quote) {
 		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 configured minimum priority fee.`
-	};
+	if (quote !== void 0) {
+		const feeRequirementDescription = quote.currentBaseFeePerGas === void 0 ? "buffered next-block base fee" : "current base fee";
+		const minimumBroadcastMaxFeePerGas = quote.currentBaseFeePerGas === void 0 ? quote.minimumMaxFeePerGas : quote.currentBaseFeePerGas + minimumPriorityFeePerGas;
+		if (maxFeePerGas < minimumBroadcastMaxFeePerGas) return {
+			valid: false,
+			code: "MaxFeeTooLow",
+			reason: `Signed transaction maxFeePerGas (${maxFeePerGas.toString()} wei) must be at least ${minimumBroadcastMaxFeePerGas.toString()} wei for the ${feeRequirementDescription} and configured minimum priority fee.`
+		};
+	}
 	return { valid: true };
 }
 async function resolveVaultTransactionFeeQuote({ readFeeHistory, readFallbackEstimate, minimumPriorityFeePerGas }) {
@@ -32571,5 +32791,5 @@ async function getIrmCurve(params) {
 }
 
 //#endregion
-export { BASE_CHAIN_ID, BASE_DEPLOYMENT, BASE_ETH_USDC_5BPS_MARKET, BASE_HYPOVAULT_ADDRESSES, BASE_HYPOVAULT_CORE_ADDRESSES, BASE_HYPOVAULT_MANAGER_ADDRESSES, BASE_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, BASE_PANOPTIC_POOL_ADDRESSES, BASE_PANOPTIC_V2_ADDRESSES, BORROW_INDEX_BITS, BPS_SCALE, BaseUSDCPLPStrategistLeaves, BaseUSDCPLPVaultPoolInfos, BaseWETHPLPStrategistLeaves, BaseWETHPLPVaultPoolInfos, CHAIN_DEPLOYMENTS, CollateralTrackerAbi, CollateralTrackerV1_1Abi, Erc1155Abi, Erc20Abi, HypoVaultAbi, HypoVaultManagerConfigSchema, HypoVaultManagerWithMerkleVerificationAbi, MAINNET_CHAIN_ID, MAINNET_DEPLOYMENT, MAINNET_ETH_USDC_5BPS_V3_PANOPTIC_POOL_ADDRESSES, MAINNET_PANOPTIC_V2_ADDRESSES, MAINNET_RISK_ENGINES, MAINNET_USDC_PLP_COMPILED_POOL_POLICY, MAINNET_USDC_PLP_POOL_POLICY, MAINNET_V3_AUTHORIZATION_BLOCK, MAINNET_WETH_PLP_COMPILED_POOL_POLICY, MAINNET_WETH_PLP_POOL_POLICY, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_STALE_DELTA_HEDGE_PRIORITY_FEE_PER_GAS, MAX_VAULT_PRIORITY_FEE_PER_GAS, MAX_VAULT_TRANSACTION_GAS_COST, MIN_VAULT_PRIORITY_FEE_PER_GAS, MainnetLegacyUSDCPLPStrategistLeaves, MainnetLegacyWETHPLPStrategistLeaves, MainnetUSDCPLPLegacyVaultPoolInfos, MainnetUSDCPLPPreviousStrategistLeaves, MainnetUSDCPLPPreviousVaultPoolInfos, MainnetUSDCPLPStrategistLeaves, MainnetUSDCPLPV3AuthorizedStrategistLeaves, MainnetUSDCPLPV3AuthorizedVaultPoolInfos, MainnetUSDCPLPVaultPoolInfos, MainnetWETHPLPLegacyVaultPoolInfos, MainnetWETHPLPPreviousStrategistLeaves, MainnetWETHPLPPreviousVaultPoolInfos, MainnetWETHPLPStrategistLeaves, MainnetWETHPLPV3AuthorizedStrategistLeaves, MainnetWETHPLPV3AuthorizedVaultPoolInfos, MainnetWETHPLPVaultPoolInfos, Multicall3Abi, NonFungiblePositionManagerAbi, PanopticFactoryV3Abi, PanopticFactoryV4Abi, PanopticHelperAbi, PanopticPoolAbi, PanopticPoolV1_1Abi, PanopticQueryV1_1Abi, PanopticVaultAccountantAbi, PanopticVaultAccountantManagerInputAbi, PoolManagerAbi, RATE_AT_TARGET_BITS, ROBINHOOD_CHAIN_ID, ROBINHOOD_DEPLOYMENT, ROBINHOOD_HYPOVAULT_ADDRESSES, ROBINHOOD_HYPOVAULT_CORE_ADDRESSES, ROBINHOOD_HYPOVAULT_MANAGER_ADDRESSES, ROBINHOOD_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, ROBINHOOD_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_PANOPTIC_V2_ADDRESSES, ROBINHOOD_RISK_ENGINES, ROBINHOOD_SPY_USDG_MARKET, ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_POOL_POLICY, RescueDistributorAbi, RobinhoodUSDGPLPStrategistLeaves, RobinhoodUSDGPLPVaultPoolInfos, SECONDS_PER_YEAR, SEPOLIA_CHAIN_ID, SEPOLIA_DEPLOYMENT, SEPOLIA_ETH_USDC_5BPS_MARKET, SEPOLIA_HYPOVAULT_ADDRESSES, SEPOLIA_HYPOVAULT_CORE_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, SEPOLIA_PANOPTIC_POOL_ADDRESSES, SEPOLIA_PANOPTIC_V2_ADDRESSES, SemiFungiblePositionManagerAbi, SemiFungiblePositionManagerV1_1Abi, SepoliaUSDCPLPStrategistLeaves, SepoliaUSDCPLPVaultPoolInfos, SepoliaWETHPLPStrategistLeaves, SepoliaWETHPLPVaultPoolInfos, Simple7702AccountAbi, StateViewAbi, TRUSTED_VAULT_SHARE_PRICE_STATUSES, UNREALIZED_INTEREST_BITS, UniswapHelperAbi, UniswapHelperV1_1Abi, UniswapMigratorAbi, UniswapV3FactoryAbi, UniswapV3PoolAbi, UsdcPlpVaultBaseProdConfig, UsdcPlpVaultMainnetLegacyConfig, UsdcPlpVaultMainnetProdConfig, UsdcPlpVaultSepoliaDevConfig, UsdcPlpVaultSepoliaProdConfig, UsdgPlpVaultRobinhoodProdConfig, VAULT_DISPLAY_NAMES_PER_CHAIN, VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN, VaultApyPreInceptionBlockError, VaultTransactionFeeEstimationError, VaultTransactionGasCostLimitError, VaultTransactionReplacementLimitError, WAD, WETHAbi, WethPlpVaultBaseProdConfig, WethPlpVaultMainnetLegacyConfig, WethPlpVaultMainnetProdConfig, WethPlpVaultSepoliaDevConfig, WethPlpVaultSepoliaProdConfig, adjustUnderlyingIdleBalance, annualizePerSecondRateWad, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, buildClaimVaultShareCalldatas, buildExecuteDepositCalldatas, buildExecuteWithdrawalCalldatas, buildManageArgs, buildManagerInput, buildManagerInputAtBlock, buildRequestWithdrawalCalldatas, buildVaultManagerInput, buildVaultManagerInputAtBlock, builderFactoryAbi, builderWalletAbi, calculateAnnualizedApyPct, calculateAssetsFromShares, calculateAvailableShares, calculateClaimableAssetsFromQueuedWithdrawals, calculateClaimableSharesFromQueuedDeposits, calculateSharesFromAssets, calculateVaultNetLendingApyPctFromTrackerInputs, calculateVaultNetLendingYieldUnderlyingFromTrackerInputs, cancelDeposit, chainToHypoVaultGraphQlAPI, clearVaultApyStrategyOverride, collateralTrackerV2Abi as collateralTrackerAbi, collateralTrackerV2Abi, computeSharePriceFromNavSnapshot, convertJsonTreeToArray, createVaultSharePriceProcessor, deriveSupplyRatePerSecWad, deriveVaultApyTimeseriesFromSharePrices, encodeApproveFunctionData, encodeCancelDepositFunctionData, encodeDepositFunctionData, encodeExecuteDepositFunctionData, encodeExecuteWithdrawalFunctionData, encodeExecuteWithdrawalMulticallFunctionData, encodeFulfillDepositsFunctionData, encodeFulfillWithdrawalsFunctionData, encodeRequestDepositFunctionData, encodeRequestWithdrawalFunctionData, encodeRequestWithdrawalMulticallFunctionData, encodeWithdrawFunctionData, executeWithdrawal, executeWithdrawalMulticall, fetchFirstDepositTimestampByVaultId, fetchVaultLendingAllocation, fetchVaultNetLendingApyPct, fetchVaultNetLendingYieldUnderlying, fetchVaultSharePriceSnapshot, fetchVaultSharePriceSnapshotWithCandidateRecovery, findLeaf, findLeafForTarget, findLeafForTargetAndSignature, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, generateProof, getAaveHoldings, getAlchemyRpcUrl, getAlchemyWsRpcUrl, getCancelDepositContractConfig, getChainDeployment, getEthUsdcMarket, getExecuteWithdrawalContractConfig, getExecuteWithdrawalMulticallContractConfig, getHypoVaultConfigForVault, getHypoVaultGraphQLClient, getIrmCurrent, getIrmCurve, getLendingAllocationRows, getMainnetV3AuthorizationArtifactsAtBlock, getMainnetV3AuthorizationGenerations, getMainnetVaultManagerRootAtBlock, getMainnetVaultManagerRootHistory, getMainnetVaultPoolConfigurationAtBlock, getMainnetVaultPoolConfigurationHistory, getMinQueuedDepositEpoch, getMorphoHoldings, getProofsFromDigests, getProofsUsingTree, getRequestDepositContractConfig, getRequestWithdrawalContractConfig, getRequestWithdrawalMulticallContractConfig, getSpyUsdgMarket, getStaleOracleOverrideBytecodeForAccountant, getStaleOracleStateOverrideForAccountant, getStkAaveHoldings, getVaultApyErrorMessage, getVaultApyStrategy, getVaultCandidatePoolInfos, getVaultDeltaHedgeHistoricalFeeQuote, getVaultDeltaHedgeInitialFeeQuote, getVaultPoolInfos, getVaultTransactionFeeQuote, getVaultTransactionReplacementFeeQuote, isExpectedHistoricalReadMiss, isIncorrectPositionListReadError, isStaleOraclePriceError, isStaleOraclePriceReadError, isSupportedChain, isTrustedVaultSharePriceStatus, packMarketState, panopticFactoryV4Abi as panopticFactoryAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticLiquidatorAbi, panopticPoolV2Abi as panopticPoolAbi, panopticPoolV2Abi, panopticQueryAbi, parseCustomError, ratePerSecWadToAprPct, recoverVaultCandidateTokenIdsByPool, requestDeposit, requestWithdrawal, requestWithdrawalMulticall, requireChainDeployment, resolveMainnetV3AuthorizationArtifacts, resolvePositionScanFromBlock, resolveVaultDisplayName, resolveVaultHistoricalCandidatesByPool, resolveVaultPoolInfosAtBlock, resolveVaultTokenIdsByPool, riskEngineAbi, semiFungiblePositionManagerV4Abi as semiFungiblePositionManagerAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, setVaultApyStrategyOverride, simulateCancelDeposit, simulateExecuteWithdrawal, simulateExecuteWithdrawalMulticall, simulateRequestDeposit, simulateRequestWithdrawal, simulateRequestWithdrawalMulticall, statusForVaultSharePriceSnapshot, useCancelDeposit, useClaimVaultShares, useExecuteWithdrawal, useRequestDeposit, useRequestWithdrawal, utilizationBpsToWad, utilizationPctToWad, validateVaultSignedTransactionFeeCaps, verifyVaultOpenTokenIdsAtBlock };
+export { BASE_CHAIN_ID, BASE_DEPLOYMENT, BASE_ETH_USDC_5BPS_MARKET, BASE_HYPOVAULT_ADDRESSES, BASE_HYPOVAULT_CORE_ADDRESSES, BASE_HYPOVAULT_MANAGER_ADDRESSES, BASE_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, BASE_PANOPTIC_POOL_ADDRESSES, BASE_PANOPTIC_V2_ADDRESSES, BORROW_INDEX_BITS, BPS_SCALE, BaseUSDCPLPStrategistLeaves, BaseUSDCPLPVaultPoolInfos, BaseWETHPLPStrategistLeaves, BaseWETHPLPVaultPoolInfos, CHAIN_DEPLOYMENTS, CollateralTrackerAbi, CollateralTrackerV1_1Abi, Erc1155Abi, Erc20Abi, HypoVaultAbi, HypoVaultManagerConfigSchema, HypoVaultManagerWithMerkleVerificationAbi, MAINNET_CHAIN_ID, MAINNET_DEPLOYMENT, MAINNET_ETH_USDC_5BPS_V3_PANOPTIC_POOL_ADDRESSES, MAINNET_PANOPTIC_V2_ADDRESSES, MAINNET_RISK_ENGINES, MAINNET_USDC_PLP_COMPILED_POOL_POLICY, MAINNET_USDC_PLP_POOL_POLICY, MAINNET_V3_AUTHORIZATION_BLOCK, MAINNET_WETH_PLP_COMPILED_POOL_POLICY, MAINNET_WETH_PLP_POOL_POLICY, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_STALE_DELTA_HEDGE_PRIORITY_FEE_PER_GAS, MAX_VAULT_PRIORITY_FEE_PER_GAS, MAX_VAULT_TRANSACTION_GAS_COST, MIN_VAULT_PRIORITY_FEE_PER_GAS, MainnetLegacyUSDCPLPStrategistLeaves, MainnetLegacyWETHPLPStrategistLeaves, MainnetUSDCPLPLegacyVaultPoolInfos, MainnetUSDCPLPPreviousStrategistLeaves, MainnetUSDCPLPPreviousVaultPoolInfos, MainnetUSDCPLPStrategistLeaves, MainnetUSDCPLPV3AuthorizedStrategistLeaves, MainnetUSDCPLPV3AuthorizedVaultPoolInfos, MainnetUSDCPLPVaultPoolInfos, MainnetWETHPLPLegacyVaultPoolInfos, MainnetWETHPLPPreviousStrategistLeaves, MainnetWETHPLPPreviousVaultPoolInfos, MainnetWETHPLPStrategistLeaves, MainnetWETHPLPV3AuthorizedStrategistLeaves, MainnetWETHPLPV3AuthorizedVaultPoolInfos, MainnetWETHPLPVaultPoolInfos, Multicall3Abi, NonFungiblePositionManagerAbi, PanopticFactoryV3Abi, PanopticFactoryV4Abi, PanopticHelperAbi, PanopticPoolAbi, PanopticPoolV1_1Abi, PanopticQueryV1_1Abi, PanopticVaultAccountantAbi, PanopticVaultAccountantManagerInputAbi, PoolManagerAbi, RATE_AT_TARGET_BITS, ROBINHOOD_CHAIN_ID, ROBINHOOD_DEPLOYMENT, ROBINHOOD_HYPOVAULT_ADDRESSES, ROBINHOOD_HYPOVAULT_CORE_ADDRESSES, ROBINHOOD_HYPOVAULT_MANAGER_ADDRESSES, ROBINHOOD_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, ROBINHOOD_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_PANOPTIC_V2_ADDRESSES, ROBINHOOD_RISK_ENGINES, ROBINHOOD_SPY_USDG_30BPS_MARKET, ROBINHOOD_SPY_USDG_30BPS_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_SPY_USDG_30BPS_POOL_DEPLOYMENT_BLOCK, ROBINHOOD_SPY_USDG_30BPS_POOL_INFO, ROBINHOOD_SPY_USDG_5BPS_MARKET, ROBINHOOD_SPY_USDG_5BPS_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_SPY_USDG_5BPS_POOL_DEPLOYMENT_BLOCK, ROBINHOOD_SPY_USDG_5BPS_POOL_INFO, ROBINHOOD_SPY_USDG_MARKET, ROBINHOOD_SPY_USDG_POOL_DEPLOYMENT_BLOCK, ROBINHOOD_SPY_USDG_POOL_INFO, ROBINHOOD_USDG_30BPS_MANAGE_ROOT, ROBINHOOD_USDG_30BPS_POOL_HASH, ROBINHOOD_USDG_5BPS_POOL_HASH, ROBINHOOD_USDG_PLP_30BPS_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_30BPS_POOL_POLICY, ROBINHOOD_USDG_PLP_5BPS_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_5BPS_POOL_POLICY, ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_POOL_POLICY, ROBINHOOD_USDG_VAULT_DEPLOYMENT_BLOCK, RescueDistributorAbi, RobinhoodUSDGPLP30bpsStrategistLeaves, RobinhoodUSDGPLP30bpsVaultPoolInfos, RobinhoodUSDGPLP5bpsStrategistLeaves, RobinhoodUSDGPLP5bpsVaultPoolInfos, RobinhoodUSDGPLPStrategistLeaves, RobinhoodUSDGPLPVaultPoolInfos, SECONDS_PER_YEAR, SEPOLIA_CHAIN_ID, SEPOLIA_DEPLOYMENT, SEPOLIA_ETH_USDC_5BPS_MARKET, SEPOLIA_HYPOVAULT_ADDRESSES, SEPOLIA_HYPOVAULT_CORE_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, SEPOLIA_PANOPTIC_POOL_ADDRESSES, SEPOLIA_PANOPTIC_V2_ADDRESSES, SemiFungiblePositionManagerAbi, SemiFungiblePositionManagerV1_1Abi, SepoliaUSDCPLPStrategistLeaves, SepoliaUSDCPLPVaultPoolInfos, SepoliaWETHPLPStrategistLeaves, SepoliaWETHPLPVaultPoolInfos, Simple7702AccountAbi, StateViewAbi, TRUSTED_VAULT_SHARE_PRICE_STATUSES, UNREALIZED_INTEREST_BITS, UniswapHelperAbi, UniswapHelperV1_1Abi, UniswapMigratorAbi, UniswapV3FactoryAbi, UniswapV3PoolAbi, UsdcPlpVaultBaseProdConfig, UsdcPlpVaultMainnetLegacyConfig, UsdcPlpVaultMainnetProdConfig, UsdcPlpVaultSepoliaDevConfig, UsdcPlpVaultSepoliaProdConfig, UsdgPlpVaultRobinhoodProdConfig, VAULT_DISPLAY_NAMES_PER_CHAIN, VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN, VaultApyPreInceptionBlockError, VaultTransactionFeeEstimationError, VaultTransactionGasCostLimitError, VaultTransactionReplacementLimitError, WAD, WETHAbi, WethPlpVaultBaseProdConfig, WethPlpVaultMainnetLegacyConfig, WethPlpVaultMainnetProdConfig, WethPlpVaultSepoliaDevConfig, WethPlpVaultSepoliaProdConfig, adjustUnderlyingIdleBalance, annualizePerSecondRateWad, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, buildClaimVaultShareCalldatas, buildExecuteDepositCalldatas, buildExecuteWithdrawalCalldatas, buildManageArgs, buildManagerInput, buildManagerInputAtBlock, buildRequestWithdrawalCalldatas, buildVaultManagerInput, buildVaultManagerInputAtBlock, builderFactoryAbi, builderWalletAbi, calculateAnnualizedApyPct, calculateAssetsFromShares, calculateAvailableShares, calculateClaimableAssetsFromQueuedWithdrawals, calculateClaimableSharesFromQueuedDeposits, calculateSharesFromAssets, calculateVaultNetLendingApyPctFromTrackerInputs, calculateVaultNetLendingYieldUnderlyingFromTrackerInputs, cancelDeposit, chainToHypoVaultGraphQlAPI, clearVaultApyStrategyOverride, collateralTrackerV2Abi as collateralTrackerAbi, collateralTrackerV2Abi, computeSharePriceFromNavSnapshot, convertJsonTreeToArray, createVaultSharePriceProcessor, deriveSupplyRatePerSecWad, deriveVaultApyTimeseriesFromSharePrices, encodeApproveFunctionData, encodeCancelDepositFunctionData, encodeDepositFunctionData, encodeExecuteDepositFunctionData, encodeExecuteWithdrawalFunctionData, encodeExecuteWithdrawalMulticallFunctionData, encodeFulfillDepositsFunctionData, encodeFulfillWithdrawalsFunctionData, encodeRequestDepositFunctionData, encodeRequestWithdrawalFunctionData, encodeRequestWithdrawalMulticallFunctionData, encodeWithdrawFunctionData, executeWithdrawal, executeWithdrawalMulticall, fetchFirstDepositTimestampByVaultId, fetchVaultLendingAllocation, fetchVaultNetLendingApyPct, fetchVaultNetLendingYieldUnderlying, fetchVaultSharePriceSnapshot, fetchVaultSharePriceSnapshotWithCandidateRecovery, findLeaf, findLeafForTarget, findLeafForTargetAndSignature, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, generateProof, getAaveHoldings, getAlchemyRpcUrl, getAlchemyWsRpcUrl, getCancelDepositContractConfig, getChainDeployment, getEthUsdcMarket, getExecuteWithdrawalContractConfig, getExecuteWithdrawalMulticallContractConfig, getHypoVaultConfigForVault, getHypoVaultGraphQLClient, getIrmCurrent, getIrmCurve, getLendingAllocationRows, getMainnetV3AuthorizationArtifactsAtBlock, getMainnetV3AuthorizationGenerations, getMainnetVaultManagerRootAtBlock, getMainnetVaultManagerRootHistory, getMainnetVaultPoolConfigurationAtBlock, getMainnetVaultPoolConfigurationHistory, getMinQueuedDepositEpoch, getMorphoHoldings, getProofsFromDigests, getProofsUsingTree, getRequestDepositContractConfig, getRequestWithdrawalContractConfig, getRequestWithdrawalMulticallContractConfig, getRobinhoodSpyUsdgAuthorizationGenerations, getSpyUsdgMarket, getStaleOracleOverrideBytecodeForAccountant, getStaleOracleStateOverrideForAccountant, getStkAaveHoldings, getVaultApyErrorMessage, getVaultApyStrategy, getVaultCandidatePoolInfos, getVaultDeltaHedgeHistoricalFeeQuote, getVaultDeltaHedgeInitialFeeQuote, getVaultManagerRootAtBlock, getVaultManagerRootHistory, getVaultPoolConfigurationAtBlock, getVaultPoolConfigurationHistory, getVaultPoolInfos, getVaultTransactionFeeQuote, getVaultTransactionReplacementFeeQuote, hashRobinhoodSpyUsdgPoolInfos, isExpectedHistoricalReadMiss, isIncorrectPositionListReadError, isStaleOraclePriceError, isStaleOraclePriceReadError, isSupportedChain, isTrustedVaultSharePriceStatus, packMarketState, panopticFactoryV4Abi as panopticFactoryAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticLiquidatorAbi, panopticPoolV2Abi as panopticPoolAbi, panopticPoolV2Abi, panopticQueryAbi, parseCustomError, ratePerSecWadToAprPct, recoverVaultCandidateTokenIdsByPool, requestDeposit, requestWithdrawal, requestWithdrawalMulticall, requireChainDeployment, resolveMainnetV3AuthorizationArtifacts, resolvePositionScanFromBlock, resolveRobinhoodSpyUsdgAuthorizationArtifacts, resolveRobinhoodSpyUsdgAuthorizationState, resolveVaultDisplayName, resolveVaultHistoricalCandidatesByPool, resolveVaultPoolInfosAtBlock, resolveVaultTokenIdsByPool, riskEngineAbi, semiFungiblePositionManagerV4Abi as semiFungiblePositionManagerAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, setVaultApyStrategyOverride, simulateCancelDeposit, simulateExecuteWithdrawal, simulateExecuteWithdrawalMulticall, simulateRequestDeposit, simulateRequestWithdrawal, simulateRequestWithdrawalMulticall, statusForVaultSharePriceSnapshot, useCancelDeposit, useClaimVaultShares, useErc20Balance, useExecuteWithdrawal, useRequestDeposit, useRequestWithdrawal, utilizationBpsToWad, utilizationPctToWad, validateVaultSignedTransactionFeeCaps, verifyVaultOpenTokenIdsAtBlock };
 //# sourceMappingURL=index.js.map