@panoptic-eng/sdk 1.0.53 → 1.0.54

package/dist/index.js

@@ -24313,23 +24313,26 @@ var _4663 = {
 		},
 		"vaults": {
 			"wethPlpVault": "0x0000000000000000000000000000000000000000",
-			"usdcPlpVault": "0x0000000000000000000000000000000000000000"
+			"usdcPlpVault": "0x0000000000000000000000000000000000000000",
+			"usdgPlpVault": "0x08B24123252Bd9c4DD473b6573D4cF67196FFC4B"
 		},
 		"managers": {
 			"wethPlpVaultManager": "0x0000000000000000000000000000000000000000",
-			"usdcPlpVaultManager": "0x0000000000000000000000000000000000000000"
+			"usdcPlpVaultManager": "0x0000000000000000000000000000000000000000",
+			"usdgPlpVaultManager": "0x67Edb096585efe88a9A1ee16c5857AB74Fc8EA87"
 		},
 		"turnkeySigners": {
 			"wethPlpVaultManager": "0x0000000000000000000000000000000000000000",
-			"usdcPlpVaultManager": "0x0000000000000000000000000000000000000000"
+			"usdcPlpVaultManager": "0x0000000000000000000000000000000000000000",
+			"usdgPlpVaultManager": "0x8FfA6DAB99f8afc64F61BeF83F0966eD6362f24F"
 		}
 	},
 	"panoptic": {
 		"pool": {
 			"version": "v4",
-			"panopticPool": "0x0000000000000000000000000000000000000000",
-			"collateralTracker0": "0x0000000000000000000000000000000000000000",
-			"collateralTracker1": "0x0000000000000000000000000000000000000000"
+			"panopticPool": "0x00000000989bcb6f24af4a1Ab2A6d6a31c98A58E",
+			"collateralTracker0": "0x49eaAC32A7CD4B8fB2209a12859a95E0b20aB0e5",
+			"collateralTracker1": "0x670C44a0FC35dbC410498e47A6290a1C3196d191"
 		},
 		"v2": {
 			"semiFungiblePositionManagerV4": "0x00000000000005C3287f136Ef5AF56c68Ea6849f",
@@ -24347,7 +24350,13 @@ var _4663 = {
 		}
 	},
 	"riskEngines": ["0x0000000000000E65545005B26207D7edFd031260", "0x0000000000000fe1e261f66ce2f44def4f5ae0cb"],
-	"markets": {},
+	"markets": { "spyUsdg": {
+		"currency0": "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
+		"currency1": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+		"fee": 3e3,
+		"tickSpacing": 60,
+		"poolId": "0xfe2a80bb5618fd14984b92ca6d45bf5ba67443ddb1435e28b2e48df2fc1526cd"
+	} },
 	"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"
@@ -24497,16 +24506,21 @@ function getChainDeployment(chainId) {
 	return CHAIN_DEPLOYMENTS[chainId];
 }
 function requireChainDeployment(chainId) {
-	const deployment = getChainDeployment(chainId);
-	if (deployment === void 0) throw new Error(`Unsupported chain deployment for chainId ${chainId}`);
-	return deployment;
+	const deployment$2 = getChainDeployment(chainId);
+	if (deployment$2 === void 0) throw new Error(`Unsupported chain deployment for chainId ${chainId}`);
+	return deployment$2;
 }
 function isSupportedChain(chainId) {
 	return getChainDeployment(chainId) !== void 0;
 }
-function getEthUsdcMarket(deployment) {
-	const market = deployment.markets.ethUsdc5bps ?? deployment.markets.ethUsdc30bps;
-	if (market === void 0) throw new Error(`Missing ETH/USDC market for chainId ${deployment.chainId}`);
+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}`);
+	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}`);
 	return market;
 }
 const MAINNET_DEPLOYMENT = CHAIN_DEPLOYMENTS[MAINNET_CHAIN_ID];
@@ -24539,6 +24553,7 @@ const ROBINHOOD_HYPOVAULT_MANAGER_TURNKEY_SIGNERS = ROBINHOOD_DEPLOYMENT.hypovau
 const ROBINHOOD_PANOPTIC_POOL_ADDRESSES = ROBINHOOD_DEPLOYMENT.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);
 
 //#endregion
 //#region ../deployments/src/vaultDisplayNames.js
@@ -24552,6 +24567,9 @@ const sepoliaDeployment = requireChainDeployment(SEPOLIA_CHAIN_ID);
 const sepoliaVaults = sepoliaDeployment.hypovault.vaults;
 const baseDeployment = requireChainDeployment(BASE_CHAIN_ID);
 const baseVaults = baseDeployment.hypovault.vaults;
+const robinhoodDeployment = requireChainDeployment(ROBINHOOD_CHAIN_ID);
+const robinhoodUsdgVault = robinhoodDeployment.hypovault.vaults.usdgPlpVault;
+if (robinhoodUsdgVault === void 0) throw new Error("Missing Robinhood USDG PLP vault address");
 const VAULT_DISPLAY_NAMES_PER_CHAIN = {
 	[MAINNET_CHAIN_ID]: {
 		[mainnetVaults.wethPlpVault.toLowerCase()]: "PLP Vault",
@@ -24566,7 +24584,8 @@ const VAULT_DISPLAY_NAMES_PER_CHAIN = {
 	[SEPOLIA_CHAIN_ID]: {
 		[sepoliaVaults.wethPlpVault.toLowerCase()]: "PLP Vault",
 		[sepoliaVaults.usdcPlpVault.toLowerCase()]: "Unicorn Vault"
-	}
+	},
+	[ROBINHOOD_CHAIN_ID]: { [robinhoodUsdgVault.toLowerCase()]: "USDG PLP Vault" }
 };
 const VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN = {
 	[MAINNET_CHAIN_ID]: {
@@ -24582,10 +24601,11 @@ const VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN = {
 	[SEPOLIA_CHAIN_ID]: {
 		[sepoliaVaults.wethPlpVault.toLowerCase()]: () => "PLP Vault",
 		[sepoliaVaults.usdcPlpVault.toLowerCase()]: () => "Unicorn Vault"
-	}
+	},
+	[ROBINHOOD_CHAIN_ID]: { [robinhoodUsdgVault.toLowerCase()]: () => "USDG PLP Vault" }
 };
-function resolveVaultDisplayName({ chainId, vaultAddress, underlyingSymbol, fallbackName }) {
-	const vaultAddressLower = vaultAddress.toLowerCase();
+function resolveVaultDisplayName({ chainId, vaultAddress: vaultAddress$1, underlyingSymbol, fallbackName }) {
+	const vaultAddressLower = vaultAddress$1.toLowerCase();
 	const resolver = VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN[chainId]?.[vaultAddressLower];
 	if (resolver !== void 0) return resolver({
 		chainId,
@@ -24775,6 +24795,7 @@ 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;
@@ -24817,6 +24838,14 @@ const MAINNET_WSPCXX_USDC_POOL_INFO = {
 	token1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
 	positionScanFromBlock: 25302077n
 };
+const ROBINHOOD_SPY_USDG_POOL_DEPLOYMENT_BLOCK = 62901925n;
+const ROBINHOOD_SPY_USDG_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
+};
 /** 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 = [
@@ -25251,6 +25280,172 @@ const UsdcPlpVaultSepoliaProdConfig = {
 	deltaHedge: { maxHedgeSlots: 12 }
 };
 
+//#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 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],
+		canSendValue: false
+	}
+];
+const dispatchLeaf = {
+	description: "Dispatch mint/burn options on SPY/USDG 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);
+
+//#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;
+if (vault === void 0 || manager === void 0) throw new Error("Missing Robinhood USDG PLP vault deployment addresses");
+const UsdgPlpVaultRobinhoodProdConfig = {
+	deployment: "prod",
+	artifactSet: "robinhood-prod",
+	vaultAssetIndex: 1n,
+	manageCycleIntervalMs: 6e5,
+	vaultCapInUnderlying: 100000000000n,
+	vaultCapInShares: 100000000000000000n,
+	allowUnlimitedDepositRequestIfCapNotReached: true,
+	maxBuyingPowerUsageBps: 6600,
+	poolDeploymentBlock: Number(ROBINHOOD_SPY_USDG_POOL_DEPLOYMENT_BLOCK),
+	chainId: ROBINHOOD_CHAIN_ID,
+	hypoVaultAddress: vault,
+	addresses: {
+		ethUsdc500bpsV4Collateral0: deployment.panoptic.pool.collateralTracker0,
+		ethUsdc500bpsV4Collateral1: deployment.panoptic.pool.collateralTracker1,
+		ethUsdc500bpsV4PanopticPool: deployment.panoptic.pool.panopticPool,
+		hypoVaultManagerWithMerkleVerification: manager,
+		hypoVault: vault,
+		underlyingToken: getSpyUsdgMarket(deployment).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,
+		allocationBps: 1e4
+	}] },
+	deltaHedge: {
+		deltaThresholdBps: 200n,
+		maxHedgeSlots: 3
+	},
+	alerts: { outOfRangeEnabled: true },
+	reporting: {
+		assetSymbol: "USDG",
+		vaultLabel: "USDG PLP"
+	}
+};
+
 //#endregion
 //#region src/hypoVault/hypoVaultManagerConfigs/wethPlpVaultBaseProdConfig.ts
 const BASE_DEPLOYMENT$1 = requireChainDeployment(BASE_CHAIN_ID);
@@ -25688,10 +25883,11 @@ const ALL_HYPO_VAULT_CONFIGS = [
 	WethPlpVaultMainnetProdConfig,
 	UsdcPlpVaultMainnetProdConfig,
 	WethPlpVaultMainnetLegacyConfig,
-	UsdcPlpVaultMainnetLegacyConfig
+	UsdcPlpVaultMainnetLegacyConfig,
+	UsdgPlpVaultRobinhoodProdConfig
 ];
-function getHypoVaultConfigForVault(vaultAddress, chainId, options) {
-	const vaultLower = vaultAddress.toLowerCase();
+function getHypoVaultConfigForVault(vaultAddress$1, chainId, options) {
+	const vaultLower = vaultAddress$1.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;
@@ -26013,7 +26209,7 @@ function isSnapshotCandidateEvent(event) {
 	return event.transactionHash !== null && event.blockNumber !== null && event.logIndex !== null;
 }
 function decodeSnapshotTransaction(params) {
-	const { account, pool, rolesContext } = params;
+	const { account, pool: pool$1, rolesContext } = params;
 	let dispatchInput = params.input;
 	let dispatchSender = params.from;
 	if (rolesContext) {
@@ -26024,14 +26220,14 @@ function decodeSnapshotTransaction(params) {
 				data: params.input
 			});
 			const [target, value, data, operation, roleKey, shouldRevert] = decodedRoleCall.args;
-			if (!pool || getAddress(target) !== getAddress(pool) || value !== 0n || operation !== 0 || roleKey.toLowerCase() !== rolesContext.roleKey.toLowerCase() || !shouldRevert) return null;
+			if (!pool$1 || getAddress(target) !== getAddress(pool$1) || 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 && (params.to === null || getAddress(params.to) !== getAddress(pool))) return null;
+	} else if (pool$1 && (params.to === null || getAddress(params.to) !== getAddress(pool$1))) return null;
 	const candidates = decodeAllDispatchCalldata(dispatchInput);
 	if (candidates.length === 0) return null;
 	return account ? selectDispatchForAccount(candidates, account, dispatchSender) : candidates[candidates.length - 1];
@@ -26059,7 +26255,7 @@ function decodeSnapshotTransaction(params) {
 * ```
 */
 async function recoverSnapshotFromTx(params) {
-	const { client, transactionHash, account, pool, rolesContext } = params;
+	const { client, transactionHash, account, pool: pool$1, rolesContext } = params;
 	const tx = await client.getTransaction({ hash: transactionHash });
 	if (tx.blockNumber == null) return null;
 	const decoded = decodeSnapshotTransaction({
@@ -26067,7 +26263,7 @@ async function recoverSnapshotFromTx(params) {
 		from: tx.from,
 		to: tx.to,
 		account,
-		pool,
+		pool: pool$1,
 		rolesContext
 	});
 	if (!decoded) return null;
@@ -26355,6 +26551,15 @@ 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 }))
+};
+
 //#endregion
 //#region src/hypoVault/hypoVaultManagerArtifacts/SepoliaUSDCPLPVaultPoolInfos.ts
 const SepoliaUSDCPLPVaultPoolInfos = {
@@ -26454,14 +26659,14 @@ const MAINNET_V3_AUTHORIZATION_TRANSITIONS = [createVaultTransition({
 	current: generation(MainnetUSDCPLPVaultPoolInfos.poolInfos, MainnetUSDCPLPStrategistLeaves)
 })];
 const authorizationCacheByClient = new WeakMap();
-function findTransition(chainId, vaultAddress) {
+function findTransition(chainId, vaultAddress$1) {
 	if (chainId !== MAINNET_CHAIN_ID) return null;
-	const normalizedVault = vaultAddress.toLowerCase();
+	const normalizedVault = vaultAddress$1.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 }) {
-	const transition = findTransition(chainId, vaultAddress);
+function getMainnetV3AuthorizationGenerations({ chainId, vaultAddress: vaultAddress$1 }) {
+	const transition = findTransition(chainId, vaultAddress$1);
 	return transition === null ? null : {
 		previous: transition.previous,
 		next: transition.next,
@@ -26473,8 +26678,8 @@ function getMainnetV3AuthorizationGenerations({ chainId, vaultAddress }) {
 * 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, blockNumber }) {
-	const transition = findTransition(chainId, vaultAddress);
+function getMainnetV3AuthorizationArtifactsAtBlock({ chainId, vaultAddress: vaultAddress$1, blockNumber }) {
+	const transition = findTransition(chainId, vaultAddress$1);
 	if (transition === null) return null;
 	const version = blockNumber < transition.activationBlockNumber ? "previous" : "next";
 	return {
@@ -26490,11 +26695,11 @@ function getMainnetV3AuthorizationArtifactsAtBlock({ chainId, vaultAddress, bloc
 * 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, blockNumber }) {
-	const transition = findTransition(chainId, vaultAddress);
+async function resolveMainnetV3AuthorizationArtifacts({ viemClient, chainId, vaultAddress: vaultAddress$1, blockNumber }) {
+	const transition = findTransition(chainId, vaultAddress$1);
 	if (transition === null) return null;
 	const resolvedBlockNumber = blockNumber ?? await getBlockNumber(viemClient);
-	const cacheKey = `${chainId}:${vaultAddress.toLowerCase()}:${resolvedBlockNumber.toString()}`;
+	const cacheKey = `${chainId}:${vaultAddress$1.toLowerCase()}:${resolvedBlockNumber.toString()}`;
 	const clientCache = authorizationCacheByClient.get(viemClient);
 	const cached = clientCache?.get(cacheKey);
 	if (cached !== void 0) return cached;
@@ -26663,9 +26868,9 @@ function copyHistory(history) {
 		managerRootTransitions: history.managerRootTransitions.map(copyManagerRootTransition)
 	};
 }
-function findHistory(chainId, vaultAddress) {
+function findHistory(chainId, vaultAddress$1) {
 	if (chainId !== MAINNET_CHAIN_ID) return null;
-	const normalizedVault = vaultAddress.toLowerCase();
+	const normalizedVault = vaultAddress$1.toLowerCase();
 	const history = MAINNET_VAULT_HISTORIES.find((candidate) => candidate.vaultAddress.toLowerCase() === normalizedVault);
 	return history === void 0 ? null : copyHistory(history);
 }
@@ -26676,19 +26881,19 @@ function latestAtBlock(values, blockNumber) {
 	}
 	return null;
 }
-function getMainnetVaultPoolConfigurationAtBlock({ chainId, vaultAddress, blockNumber }) {
-	const history = findHistory(chainId, vaultAddress);
+function getMainnetVaultPoolConfigurationAtBlock({ chainId, vaultAddress: vaultAddress$1, blockNumber }) {
+	const history = findHistory(chainId, vaultAddress$1);
 	return history === null ? null : latestAtBlock(history.poolConfigurations, blockNumber);
 }
-function getMainnetVaultManagerRootAtBlock({ chainId, vaultAddress, blockNumber }) {
-	const history = findHistory(chainId, vaultAddress);
+function getMainnetVaultManagerRootAtBlock({ chainId, vaultAddress: vaultAddress$1, blockNumber }) {
+	const history = findHistory(chainId, vaultAddress$1);
 	return history === null ? null : latestAtBlock(history.managerRootTransitions, blockNumber);
 }
-function getMainnetVaultPoolConfigurationHistory({ chainId, vaultAddress }) {
-	return findHistory(chainId, vaultAddress)?.poolConfigurations ?? null;
+function getMainnetVaultPoolConfigurationHistory({ chainId, vaultAddress: vaultAddress$1 }) {
+	return findHistory(chainId, vaultAddress$1)?.poolConfigurations ?? null;
 }
-function getMainnetVaultManagerRootHistory({ chainId, vaultAddress }) {
-	return findHistory(chainId, vaultAddress)?.managerRootTransitions ?? null;
+function getMainnetVaultManagerRootHistory({ chainId, vaultAddress: vaultAddress$1 }) {
+	return findHistory(chainId, vaultAddress$1)?.managerRootTransitions ?? null;
 }
 
 //#endregion
@@ -26818,7 +27023,8 @@ const VAULT_POOL_INFOS_BY_CHAIN = {
 		MainnetWETHPLPLegacyVaultPoolInfos
 	],
 	[SEPOLIA_CHAIN_ID]: [SepoliaUSDCPLPVaultPoolInfos, SepoliaWETHPLPVaultPoolInfos],
-	[BASE_CHAIN_ID]: [BaseUSDCPLPVaultPoolInfos, BaseWETHPLPVaultPoolInfos]
+	[BASE_CHAIN_ID]: [BaseUSDCPLPVaultPoolInfos, BaseWETHPLPVaultPoolInfos],
+	[ROBINHOOD_CHAIN_ID]: [RobinhoodUSDGPLPVaultPoolInfos]
 };
 const GET_POOL_ACCOUNT_BALANCE_CANDIDATES = `
   query PoolAccountBalanceCandidates(
@@ -26916,7 +27122,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, candidatesByPool, fetchFn }) {
+async function collectPoolAccountBalanceCandidates({ endpoint, poolIds, vaultAddress: vaultAddress$1, candidatesByPool, fetchFn }) {
 	for (let skip = 0;; skip += PAGE_SIZE) {
 		const page = await postGraphQL({
 			endpoint,
@@ -26925,7 +27131,7 @@ async function collectPoolAccountBalanceCandidates({ endpoint, poolIds, vaultAdd
 				first: PAGE_SIZE,
 				skip,
 				poolIds,
-				vault: vaultAddress
+				vault: vaultAddress$1
 			},
 			fetchFn
 		});
@@ -27025,8 +27231,8 @@ async function filterOpenTokenIdsAtBlock({ viemClient, poolAddress, account, can
 	const openTokenIds = await collectOpen(candidates);
 	return sortBigintsAscending(openTokenIds);
 }
-function getVaultPoolInfos(vaultAddress, chainId) {
-	const vaultAddressLower = toLowerAddress$1(vaultAddress);
+function getVaultPoolInfos(vaultAddress$1, chainId) {
+	const vaultAddressLower = toLowerAddress$1(vaultAddress$1);
 	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 ?? [];
@@ -27035,12 +27241,12 @@ function getVaultPoolInfos(vaultAddress, 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, chainId) {
+function getVaultCandidatePoolInfos(vaultAddress$1, chainId) {
 	const generations = getMainnetV3AuthorizationGenerations({
 		chainId,
-		vaultAddress
+		vaultAddress: vaultAddress$1
 	});
-	const candidates = generations === null ? getVaultPoolInfos(vaultAddress, chainId) : [
+	const candidates = generations === null ? getVaultPoolInfos(vaultAddress$1, chainId) : [
 		...generations.previous.poolInfos,
 		...generations.next.poolInfos,
 		...generations.current.poolInfos
@@ -27053,21 +27259,21 @@ function getVaultCandidatePoolInfos(vaultAddress, chainId) {
 	return [...byPoolAddress.values()];
 }
 /** Selects the pool tuple authorized at an exact block before encoding manager input. */
-async function resolveVaultPoolInfosAtBlock({ viemClient, chainId, vaultAddress, blockNumber }) {
+async function resolveVaultPoolInfosAtBlock({ viemClient, chainId, vaultAddress: vaultAddress$1, blockNumber }) {
 	if (chainId === MAINNET_CHAIN_ID && blockNumber >= MAINNET_V3_AUTHORIZATION_BLOCK) {
 		const authorization = await resolveMainnetV3AuthorizationArtifacts({
 			viemClient,
 			chainId,
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			blockNumber
 		});
 		if (authorization !== null) return authorization.poolInfos;
 	}
 	return getMainnetVaultPoolConfigurationAtBlock({
 		chainId,
-		vaultAddress,
+		vaultAddress: vaultAddress$1,
 		blockNumber
-	})?.poolInfos ?? getVaultPoolInfos(vaultAddress, chainId);
+	})?.poolInfos ?? getVaultPoolInfos(vaultAddress$1, chainId);
 }
 /**
 * Enrich a cached subgraph candidate superset with the authoritative position
@@ -27079,7 +27285,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, candidatesByPool, poolInfos, blockNumber, fromBlock }) {
+async function recoverVaultCandidateTokenIdsByPool({ viemClient, chainId, vaultAddress: vaultAddress$1, 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 ?? [];
@@ -27093,11 +27299,11 @@ async function recoverVaultCandidateTokenIdsByPool({ viemClient, chainId, vaultA
 			client: viemClient,
 			chainId: BigInt(chainId),
 			poolAddress: poolInfo.pool,
-			account: vaultAddress,
+			account: vaultAddress$1,
 			fromBlock: scanFromBlock,
 			toBlock: blockNumber
 		});
-		if (recoveredIds === null) throw new Error(`Could not recover an authoritative position list for vault ${vaultAddress} 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$1} in pool ${poolInfo.pool} between blocks ${scanFromBlock} and ${blockNumber}`);
 		const candidates = sortBigintsAscending(new Set([...cachedIds, ...recoveredIds]));
 		return {
 			poolAddress: poolInfo.pool,
@@ -27113,15 +27319,15 @@ 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, managerAddress, poolInfos, panopticSubgraphUrl, fetchFn = fetch }) {
-	const resolvedPoolInfos = poolInfos ?? getVaultPoolInfos(vaultAddress, chainId);
+async function resolveVaultHistoricalCandidatesByPool({ chainId, vaultAddress: vaultAddress$1, managerAddress, poolInfos, panopticSubgraphUrl, fetchFn = fetch }) {
+	const resolvedPoolInfos = poolInfos ?? getVaultPoolInfos(vaultAddress$1, 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);
+	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 poolIds = Array.from(new Set(resolvedPoolInfos.map((poolInfo) => toLowerAddress$1(poolInfo.pool))));
 	const balanceCandidatesByPool = new Map();
@@ -27156,13 +27362,13 @@ async function resolveVaultHistoricalCandidatesByPool({ chainId, vaultAddress, m
 * 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, candidatesByPool, blockNumber }) {
+async function verifyVaultOpenTokenIdsAtBlock({ viemClient, vaultAddress: vaultAddress$1, candidatesByPool, blockNumber }) {
 	const tokenIdsByPool = [];
 	for (const { poolAddress, candidates } of candidatesByPool) {
 		const openTokenIds = await filterOpenTokenIdsAtBlock({
 			viemClient,
 			poolAddress,
-			account: vaultAddress,
+			account: vaultAddress$1,
 			candidates,
 			blockNumber
 		});
@@ -27170,12 +27376,12 @@ async function verifyVaultOpenTokenIdsAtBlock({ viemClient, vaultAddress, candid
 	}
 	return tokenIdsByPool;
 }
-async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress, managerAddress, poolInfos, panopticSubgraphUrl, verificationBlockNumber, fetchFn = fetch }) {
-	const resolvedPoolInfos = poolInfos ?? getVaultPoolInfos(vaultAddress, chainId);
+async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress: vaultAddress$1, managerAddress, poolInfos, panopticSubgraphUrl, verificationBlockNumber, fetchFn = fetch }) {
+	const resolvedPoolInfos = poolInfos ?? getVaultPoolInfos(vaultAddress$1, 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);
+	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 poolIds = Array.from(new Set(resolvedPoolInfos.map((poolInfo) => toLowerAddress$1(poolInfo.pool))));
 	const balanceCandidatesByPool = new Map();
@@ -27204,7 +27410,7 @@ async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress, m
 			const historicalOpenTokenIds = await filterOpenTokenIdsAtBlock({
 				viemClient,
 				poolAddress: poolInfo.pool,
-				account: vaultAddress,
+				account: vaultAddress$1,
 				candidates: historicalCandidates,
 				blockNumber: verificationBlockNumber
 			});
@@ -27226,7 +27432,7 @@ async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress, m
 				abi: panopticPoolV2Abi$1,
 				functionName: "getFullPositionsData",
 				args: [
-					vaultAddress,
+					vaultAddress$1,
 					false,
 					eventCandidates
 				],
@@ -27252,12 +27458,12 @@ async function resolveVaultTokenIdsByPool({ viemClient, chainId, vaultAddress, m
 	}
 	return tokenIdsByPool;
 }
-async function buildVaultManagerInput({ viemClient, chainId, vaultAddress, underlyingToken, managerAddress, panopticSubgraphUrl, fetchFn }) {
+async function buildVaultManagerInput({ viemClient, chainId, vaultAddress: vaultAddress$1, underlyingToken, managerAddress, panopticSubgraphUrl, fetchFn }) {
 	const blockNumber = await getBlockNumber(viemClient);
 	return buildVaultManagerInputAtBlock({
 		viemClient,
 		chainId,
-		vaultAddress,
+		vaultAddress: vaultAddress$1,
 		underlyingToken,
 		blockNumber,
 		managerAddress,
@@ -27265,18 +27471,18 @@ async function buildVaultManagerInput({ viemClient, chainId, vaultAddress, under
 		fetchFn
 	});
 }
-async function buildVaultManagerInputAtBlock({ viemClient, chainId, vaultAddress, underlyingToken, blockNumber, managerAddress, panopticSubgraphUrl, fetchFn }) {
+async function buildVaultManagerInputAtBlock({ viemClient, chainId, vaultAddress: vaultAddress$1, underlyingToken, blockNumber, managerAddress, panopticSubgraphUrl, fetchFn }) {
 	const poolInfos = await resolveVaultPoolInfosAtBlock({
 		viemClient,
 		chainId,
-		vaultAddress,
+		vaultAddress: vaultAddress$1,
 		blockNumber
 	});
 	if (poolInfos.length === 0) return DEFAULT_MANAGER_INPUT$1;
 	const tokenIds = await resolveVaultTokenIdsByPool({
 		viemClient,
 		chainId,
-		vaultAddress,
+		vaultAddress: vaultAddress$1,
 		managerAddress,
 		poolInfos,
 		panopticSubgraphUrl,
@@ -27310,10 +27516,10 @@ const erc20BalanceOfAbi = [{
 function toLowerAddress(address) {
 	return address.toLowerCase();
 }
-function discoverPoolAddresses$1({ chainId, vaultAddress }) {
+function discoverPoolAddresses$1({ chainId, vaultAddress: vaultAddress$1 }) {
 	const discoveredAddresses = [];
 	const seen = new Set();
-	const config = getHypoVaultConfigForVault(vaultAddress, chainId);
+	const config = getHypoVaultConfigForVault(vaultAddress$1, chainId);
 	const poolFromConfig = config?.addresses?.ethUsdc500bpsV4PanopticPool;
 	if (poolFromConfig !== void 0) {
 		const key = toLowerAddress(poolFromConfig);
@@ -27322,7 +27528,7 @@ function discoverPoolAddresses$1({ chainId, vaultAddress }) {
 			discoveredAddresses.push(poolFromConfig);
 		}
 	}
-	const artifactPoolInfos = getVaultPoolInfos(vaultAddress, chainId);
+	const artifactPoolInfos = getVaultPoolInfos(vaultAddress$1, chainId);
 	for (const poolInfo of artifactPoolInfos) {
 		const key = toLowerAddress(poolInfo.pool);
 		if (!seen.has(key)) {
@@ -27338,10 +27544,10 @@ function getUnderlyingIndex({ underlyingTokenAddress, token0Asset, token1Asset }
 	if (toLowerAddress(token1Asset) === underlyingLower) return 1;
 	return null;
 }
-async function getLendingAllocationRows({ client, chainId, vaultAddress, underlyingTokenAddress, blockNumber }) {
+async function getLendingAllocationRows({ client, chainId, vaultAddress: vaultAddress$1, underlyingTokenAddress, blockNumber }) {
 	const poolAddresses = discoverPoolAddresses$1({
 		chainId,
-		vaultAddress
+		vaultAddress: vaultAddress$1
 	});
 	const poolRows = await Promise.all(poolAddresses.map(async (poolAddress) => {
 		const metadata = await getPoolMetadata({
@@ -27362,7 +27568,7 @@ async function getLendingAllocationRows({ client, chainId, vaultAddress, underly
 		}), getAccountCollateral({
 			client,
 			poolAddress,
-			account: vaultAddress,
+			account: vaultAddress$1,
 			blockNumber
 		})]);
 		const allocationUnderlying = underlyingIndex === 0 ? accountCollateral.token0.assets : accountCollateral.token1.assets;
@@ -27383,7 +27589,7 @@ async function getLendingAllocationRows({ client, chainId, vaultAddress, underly
 		address: underlyingTokenAddress,
 		abi: erc20BalanceOfAbi,
 		functionName: "balanceOf",
-		args: [vaultAddress],
+		args: [vaultAddress$1],
 		blockNumber
 	});
 	const idleRow = {
@@ -27477,10 +27683,10 @@ function isNativeToken(tokenAddress) {
 function addressesEqual(a, b) {
 	return a.toLowerCase() === b.toLowerCase();
 }
-function discoverPoolAddresses({ chainId, vaultAddress }) {
+function discoverPoolAddresses({ chainId, vaultAddress: vaultAddress$1 }) {
 	const seen = new Set();
 	const addresses = [];
-	const config = getHypoVaultConfigForVault(vaultAddress, chainId);
+	const config = getHypoVaultConfigForVault(vaultAddress$1, chainId);
 	const configuredPool = config?.addresses?.ethUsdc500bpsV4PanopticPool;
 	if (configuredPool !== void 0) {
 		const key = configuredPool.toLowerCase();
@@ -27489,7 +27695,7 @@ function discoverPoolAddresses({ chainId, vaultAddress }) {
 			addresses.push(configuredPool);
 		}
 	}
-	const artifactInfos = getVaultPoolInfos(vaultAddress, chainId);
+	const artifactInfos = getVaultPoolInfos(vaultAddress$1, chainId);
 	for (const info of artifactInfos) {
 		const key = info.pool.toLowerCase();
 		if (!seen.has(key)) {
@@ -27649,10 +27855,10 @@ function calculateVaultNetLendingYieldUnderlyingFromTrackerInputs({ inputs, inte
 	}
 	return sawAssets ? totalNetYieldUnderlying : null;
 }
-async function fetchVaultNetLendingApyPct({ client, chainId, vaultAddress, underlyingTokenAddress, blockNumber }) {
+async function fetchVaultNetLendingApyPct({ client, chainId, vaultAddress: vaultAddress$1, underlyingTokenAddress, blockNumber }) {
 	const poolAddresses = discoverPoolAddresses({
 		chainId,
-		vaultAddress
+		vaultAddress: vaultAddress$1
 	});
 	if (poolAddresses.length === 0) return null;
 	const poolContexts = await Promise.all(poolAddresses.map(async (poolAddress) => {
@@ -27712,14 +27918,14 @@ async function fetchVaultNetLendingApyPct({ client, chainId, vaultAddress, under
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "assetsOf",
-				args: [vaultAddress],
+				args: [vaultAddress$1],
 				...blockNumber === void 0 ? {} : { blockNumber }
 			}),
 			client.readContract({
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "interestState",
-				args: [vaultAddress],
+				args: [vaultAddress$1],
 				...blockNumber === void 0 ? {} : { blockNumber }
 			}),
 			client.readContract({
@@ -27744,10 +27950,10 @@ async function fetchVaultNetLendingApyPct({ client, chainId, vaultAddress, under
 	})));
 	return calculateVaultNetLendingApyPctFromTrackerInputs(trackerInputs.filter((input) => input !== null));
 }
-async function fetchVaultNetLendingYieldUnderlying({ client, chainId, vaultAddress, underlyingTokenAddress, blockNumber, intervalSeconds }) {
+async function fetchVaultNetLendingYieldUnderlying({ client, chainId, vaultAddress: vaultAddress$1, underlyingTokenAddress, blockNumber, intervalSeconds }) {
 	const poolAddresses = discoverPoolAddresses({
 		chainId,
-		vaultAddress
+		vaultAddress: vaultAddress$1
 	});
 	if (poolAddresses.length === 0) return null;
 	const poolContexts = await Promise.all(poolAddresses.map(async (poolAddress) => {
@@ -27807,14 +28013,14 @@ async function fetchVaultNetLendingYieldUnderlying({ client, chainId, vaultAddre
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "assetsOf",
-				args: [vaultAddress],
+				args: [vaultAddress$1],
 				blockNumber
 			}),
 			client.readContract({
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "interestState",
-				args: [vaultAddress],
+				args: [vaultAddress$1],
 				blockNumber
 			}),
 			client.readContract({
@@ -27842,14 +28048,14 @@ async function fetchVaultNetLendingYieldUnderlying({ client, chainId, vaultAddre
 		intervalSeconds
 	});
 }
-async function fetchVaultLendingAllocation({ client, chainId, vaultAddress, underlyingTokenAddress, blockNumber }) {
+async function fetchVaultLendingAllocation({ client, chainId, vaultAddress: vaultAddress$1, underlyingTokenAddress, blockNumber }) {
 	const [reservedWithdrawalAssetsRaw, depositEpochRaw] = await Promise.all([client.readContract({
-		address: vaultAddress,
+		address: vaultAddress$1,
 		abi: HypoVaultAbi,
 		functionName: "reservedWithdrawalAssets",
 		...blockNumber === void 0 ? {} : { blockNumber }
 	}), client.readContract({
-		address: vaultAddress,
+		address: vaultAddress$1,
 		abi: HypoVaultAbi,
 		functionName: "depositEpoch",
 		...blockNumber === void 0 ? {} : { blockNumber }
@@ -27857,7 +28063,7 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress, unde
 	const reservedWithdrawalAssets = toBigInt$1(reservedWithdrawalAssetsRaw) ?? 0n;
 	const depositEpoch = toBigInt$1(depositEpochRaw);
 	const depositEpochStateRaw = depositEpoch === null ? null : await client.readContract({
-		address: vaultAddress,
+		address: vaultAddress$1,
 		abi: HypoVaultAbi,
 		functionName: "depositEpochState",
 		args: [depositEpoch],
@@ -27866,7 +28072,7 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress, unde
 	const unfulfilledDepositAssets = depositEpochStateRaw === null ? 0n : getAssetsDepositedFromDepositEpochState$1(depositEpochStateRaw);
 	const poolAddresses = discoverPoolAddresses({
 		chainId,
-		vaultAddress
+		vaultAddress: vaultAddress$1
 	});
 	const poolContexts = await Promise.all(poolAddresses.map(async (poolAddress) => {
 		const [collateral0Address, collateral1Address] = await Promise.all([client.readContract({
@@ -27947,7 +28153,7 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress, unde
 				address: trackerAddress,
 				abi: collateralTrackerV2Abi,
 				functionName: "assetsOf",
-				args: [vaultAddress],
+				args: [vaultAddress$1],
 				...blockNumber === void 0 ? {} : { blockNumber }
 			}),
 			client.readContract({
@@ -28022,7 +28228,7 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress, unde
 		const balance = await readTokenBalance({
 			client,
 			tokenAddress: address,
-			owner: vaultAddress,
+			owner: vaultAddress$1,
 			blockNumber
 		});
 		const adjustedBalance = addressesEqual(address, underlyingTokenAddress) ? adjustUnderlyingIdleBalance({
@@ -28112,8 +28318,8 @@ async function fetchVaultLendingAllocation({ client, chainId, vaultAddress, unde
 
 //#endregion
 //#region src/hypoVault/cancelDeposit/cancelDeposit.ts
-const getCancelDepositContractConfig = ({ vaultAddress }) => ({
-	address: vaultAddress,
+const getCancelDepositContractConfig = ({ vaultAddress: vaultAddress$1 }) => ({
+	address: vaultAddress$1,
 	abi: HypoVaultAbi,
 	functionName: "cancelDeposit",
 	args: []
@@ -28125,15 +28331,15 @@ function encodeCancelDepositFunctionData() {
 		args: []
 	});
 }
-function simulateCancelDeposit({ viemClient, vaultAddress, account }) {
+function simulateCancelDeposit({ viemClient, vaultAddress: vaultAddress$1, account }) {
 	return simulateContract(viemClient, {
-		...getCancelDepositContractConfig({ vaultAddress }),
+		...getCancelDepositContractConfig({ vaultAddress: vaultAddress$1 }),
 		account
 	});
 }
-function cancelDeposit({ walletClient, vaultAddress, account }) {
+function cancelDeposit({ walletClient, vaultAddress: vaultAddress$1, account }) {
 	return writeContract(walletClient, {
-		...getCancelDepositContractConfig({ vaultAddress }),
+		...getCancelDepositContractConfig({ vaultAddress: vaultAddress$1 }),
 		account
 	});
 }
@@ -28170,12 +28376,12 @@ const isErrorUserRejection = (errorMessage) => errorMessage.includes("User rejec
 
 //#endregion
 //#region src/hypoVault/cancelDeposit/hooks/use-cancel-deposit.ts
-const useCancelDeposit = ({ chainId, vaultAddress, onWaitSuccess }) => {
+const useCancelDeposit = ({ chainId, vaultAddress: vaultAddress$1, onWaitSuccess }) => {
 	const { address: account } = useAccount();
-	const canSimulate = vaultAddress !== zeroAddress && account != null && account !== zeroAddress;
+	const canSimulate = vaultAddress$1 !== zeroAddress && account != null && account !== zeroAddress;
 	const simulate = useSimulateContract({
 		chainId,
-		...getCancelDepositContractConfig({ vaultAddress }),
+		...getCancelDepositContractConfig({ vaultAddress: vaultAddress$1 }),
 		account,
 		query: {
 			enabled: canSimulate,
@@ -28251,51 +28457,51 @@ function encodeExecuteWithdrawalMulticallFunctionData({ multicallCalldatas }) {
 		args: [multicallCalldatas]
 	});
 }
-const getExecuteWithdrawalContractConfig = ({ vaultAddress, user, epoch }) => ({
-	address: vaultAddress,
+const getExecuteWithdrawalContractConfig = ({ vaultAddress: vaultAddress$1, user, epoch }) => ({
+	address: vaultAddress$1,
 	abi: HypoVaultAbi,
 	functionName: "executeWithdrawal",
 	args: [user, epoch]
 });
-const getExecuteWithdrawalMulticallContractConfig = ({ vaultAddress, multicallCalldatas }) => ({
-	address: vaultAddress,
+const getExecuteWithdrawalMulticallContractConfig = ({ vaultAddress: vaultAddress$1, multicallCalldatas }) => ({
+	address: vaultAddress$1,
 	abi: HypoVaultAbi,
 	functionName: "multicall",
 	args: [multicallCalldatas]
 });
-function simulateExecuteWithdrawal({ viemClient, vaultAddress, user, epoch, account }) {
+function simulateExecuteWithdrawal({ viemClient, vaultAddress: vaultAddress$1, user, epoch, account }) {
 	return simulateContract(viemClient, {
 		...getExecuteWithdrawalContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			user,
 			epoch
 		}),
 		account
 	});
 }
-function executeWithdrawal({ walletClient, vaultAddress, user, epoch, account }) {
+function executeWithdrawal({ walletClient, vaultAddress: vaultAddress$1, user, epoch, account }) {
 	return writeContract(walletClient, {
 		...getExecuteWithdrawalContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			user,
 			epoch
 		}),
 		account
 	});
 }
-function simulateExecuteWithdrawalMulticall({ viemClient, vaultAddress, multicallCalldatas, account }) {
+function simulateExecuteWithdrawalMulticall({ viemClient, vaultAddress: vaultAddress$1, multicallCalldatas, account }) {
 	return simulateContract(viemClient, {
 		...getExecuteWithdrawalMulticallContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			multicallCalldatas
 		}),
 		account
 	});
 }
-function executeWithdrawalMulticall({ walletClient, vaultAddress, multicallCalldatas, account }) {
+function executeWithdrawalMulticall({ walletClient, vaultAddress: vaultAddress$1, multicallCalldatas, account }) {
 	return writeContract(walletClient, {
 		...getExecuteWithdrawalMulticallContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			multicallCalldatas
 		}),
 		account
@@ -28375,7 +28581,7 @@ const selectExecutableWithdrawalEpochs = ({ desiredAssets, maxAssetsToExecute, c
 		assetsToExecute: accumulatedAssets
 	};
 };
-const useExecuteWithdrawal = ({ chainId, vaultAddress, desiredAssets, maxAssetsToExecute, queuedWithdrawals, withdrawalEpochStates, currentWithdrawalEpoch, simulationAccount, onWaitSuccess }) => {
+const useExecuteWithdrawal = ({ chainId, vaultAddress: vaultAddress$1, desiredAssets, maxAssetsToExecute, queuedWithdrawals, withdrawalEpochStates, currentWithdrawalEpoch, simulationAccount, onWaitSuccess }) => {
 	const { address: account } = useAccount();
 	const simulatedAccount = simulationAccount ?? account;
 	const user = simulatedAccount ?? zeroAddress;
@@ -28419,11 +28625,11 @@ const useExecuteWithdrawal = ({ chainId, vaultAddress, desiredAssets, maxAssetsT
 		assetsToExecute,
 		claimableAssets: claimableWithdrawals.totalAssets
 	});
-	const canSimulate = multicallCalldatas.length > 0 && vaultAddress !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
+	const canSimulate = multicallCalldatas.length > 0 && vaultAddress$1 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
 	const simulate = useSimulateContract({
 		chainId,
 		...getExecuteWithdrawalMulticallContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			multicallCalldatas
 		}),
 		account: simulatedAccount,
@@ -29507,6 +29713,7 @@ const HypoVaultManagerConfigSchema = z.object({
 		"base",
 		"mainnet-prod",
 		"mainnet-legacy",
+		"robinhood-prod",
 		"sepolia"
 	]).optional(),
 	vaultAssetIndex: z.union([z.literal(0n), z.literal(1n)]),
@@ -29539,7 +29746,11 @@ const HypoVaultManagerConfigSchema = z.object({
 		maxHedgeSlots: z.number().int().positive().optional(),
 		timedRehedge: timedRehedgeSchema.optional()
 	}).optional(),
-	alerts: z.object({ outOfRangeEnabled: z.boolean().optional() }).optional()
+	alerts: z.object({ outOfRangeEnabled: z.boolean().optional() }).optional(),
+	reporting: z.object({
+		assetSymbol: z.string().min(1),
+		vaultLabel: z.string().min(1)
+	}).optional()
 });
 
 //#endregion
@@ -29568,8 +29779,8 @@ function encodeFulfillWithdrawalsFunctionData({ sharesToFulfill, maxAssetsReceiv
 
 //#endregion
 //#region src/hypoVault/requestDeposit/requestDeposit.ts
-const getRequestDepositContractConfig = ({ vaultAddress, assets }) => ({
-	address: vaultAddress,
+const getRequestDepositContractConfig = ({ vaultAddress: vaultAddress$1, assets }) => ({
+	address: vaultAddress$1,
 	abi: HypoVaultAbi,
 	functionName: "requestDeposit",
 	args: [assets]
@@ -29581,19 +29792,19 @@ function encodeRequestDepositFunctionData({ assets }) {
 		args: [assets]
 	});
 }
-function simulateRequestDeposit({ viemClient, vaultAddress, assets, account }) {
+function simulateRequestDeposit({ viemClient, vaultAddress: vaultAddress$1, assets, account }) {
 	return simulateContract(viemClient, {
 		...getRequestDepositContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			assets
 		}),
 		account
 	});
 }
-function requestDeposit({ walletClient, vaultAddress, assets, account }) {
+function requestDeposit({ walletClient, vaultAddress: vaultAddress$1, assets, account }) {
 	return writeContract(walletClient, {
 		...getRequestDepositContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			assets
 		}),
 		account
@@ -29604,16 +29815,16 @@ function requestDeposit({ walletClient, vaultAddress, assets, account }) {
 //#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, assets, tokenAddress, simulationAccount, onWaitSuccess }) => {
+const useRequestDeposit = ({ chainId, vaultAddress: vaultAddress$1, assets, tokenAddress, simulationAccount, onWaitSuccess }) => {
 	const { address: account } = useAccount();
 	const simulatedAccount = simulationAccount ?? account;
-	const canReadAllowance = simulatedAccount != null && simulatedAccount !== zeroAddress && tokenAddress !== zeroAddress && vaultAddress !== zeroAddress;
+	const canReadAllowance = simulatedAccount != null && simulatedAccount !== zeroAddress && tokenAddress !== zeroAddress && vaultAddress$1 !== zeroAddress;
 	const allowanceRead = useReadContract({
 		chainId,
 		address: canReadAllowance ? tokenAddress : void 0,
 		abi: Erc20Abi,
 		functionName: "allowance",
-		args: canReadAllowance ? [simulatedAccount, vaultAddress] : void 0,
+		args: canReadAllowance ? [simulatedAccount, vaultAddress$1] : void 0,
 		query: { enabled: canReadAllowance }
 	});
 	const allowanceKnown = allowanceRead.data !== void 0;
@@ -29627,7 +29838,7 @@ const useRequestDeposit = ({ chainId, vaultAddress, assets, tokenAddress, simula
 		address: tokenAddress,
 		abi: Erc20Abi,
 		functionName: "approve",
-		args: [vaultAddress, maxUint256],
+		args: [vaultAddress$1, maxUint256],
 		account,
 		query: {
 			enabled: allowanceKnown && tokenNeedsApproval && assets > 0n && account != null && canApproveForSimulatedAccount,
@@ -29646,12 +29857,12 @@ const useRequestDeposit = ({ chainId, vaultAddress, assets, tokenAddress, simula
 	const simulate = useSimulateContract({
 		chainId,
 		...getRequestDepositContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			assets
 		}),
 		account: simulatedAccount,
 		query: {
-			enabled: allowanceKnown && !tokenNeedsApproval && assets > 0n && vaultAddress !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress,
+			enabled: allowanceKnown && !tokenNeedsApproval && assets > 0n && vaultAddress$1 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress,
 			retry: false
 		}
 	});
@@ -29910,49 +30121,49 @@ function encodeRequestWithdrawalMulticallFunctionData({ multicallCalldatas }) {
 		args: [multicallCalldatas]
 	});
 }
-const getRequestWithdrawalContractConfig = ({ vaultAddress, shares }) => ({
-	address: vaultAddress,
+const getRequestWithdrawalContractConfig = ({ vaultAddress: vaultAddress$1, shares }) => ({
+	address: vaultAddress$1,
 	abi: HypoVaultAbi,
 	functionName: "requestWithdrawal",
 	args: [shares]
 });
-const getRequestWithdrawalMulticallContractConfig = ({ vaultAddress, multicallCalldatas }) => ({
-	address: vaultAddress,
+const getRequestWithdrawalMulticallContractConfig = ({ vaultAddress: vaultAddress$1, multicallCalldatas }) => ({
+	address: vaultAddress$1,
 	abi: HypoVaultAbi,
 	functionName: "multicall",
 	args: [multicallCalldatas]
 });
-function simulateRequestWithdrawal({ viemClient, vaultAddress, shares, account }) {
+function simulateRequestWithdrawal({ viemClient, vaultAddress: vaultAddress$1, shares, account }) {
 	return simulateContract(viemClient, {
 		...getRequestWithdrawalContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			shares
 		}),
 		account
 	});
 }
-function requestWithdrawal({ walletClient, vaultAddress, shares, account }) {
+function requestWithdrawal({ walletClient, vaultAddress: vaultAddress$1, shares, account }) {
 	return writeContract(walletClient, {
 		...getRequestWithdrawalContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			shares
 		}),
 		account
 	});
 }
-function simulateRequestWithdrawalMulticall({ viemClient, vaultAddress, multicallCalldatas, account }) {
+function simulateRequestWithdrawalMulticall({ viemClient, vaultAddress: vaultAddress$1, multicallCalldatas, account }) {
 	return simulateContract(viemClient, {
 		...getRequestWithdrawalMulticallContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			multicallCalldatas
 		}),
 		account
 	});
 }
-function requestWithdrawalMulticall({ walletClient, vaultAddress, multicallCalldatas, account }) {
+function requestWithdrawalMulticall({ walletClient, vaultAddress: vaultAddress$1, multicallCalldatas, account }) {
 	return writeContract(walletClient, {
 		...getRequestWithdrawalMulticallContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			multicallCalldatas
 		}),
 		account
@@ -30023,7 +30234,7 @@ function buildRequestWithdrawalCalldatas({ user, desiredAssets, requestAllAvaila
 
 //#endregion
 //#region src/hypoVault/requestWithdrawal/hooks/use-claim-vault-shares.ts
-const useClaimVaultShares = ({ chainId, vaultAddress, queuedDeposits, depositEpochStates, currentDepositEpoch, simulationAccount, onWaitSuccess }) => {
+const useClaimVaultShares = ({ chainId, vaultAddress: vaultAddress$1, queuedDeposits, depositEpochStates, currentDepositEpoch, simulationAccount, onWaitSuccess }) => {
 	const { address: account } = useAccount();
 	const simulatedAccount = simulationAccount ?? account;
 	const user = simulatedAccount ?? zeroAddress;
@@ -30038,11 +30249,11 @@ const useClaimVaultShares = ({ chainId, vaultAddress, queuedDeposits, depositEpo
 		depositEpochStates,
 		currentDepositEpoch
 	]);
-	const canSimulate = multicallCalldatas.length > 0 && vaultAddress !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
+	const canSimulate = multicallCalldatas.length > 0 && vaultAddress$1 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
 	const simulate = useSimulateContract({
 		chainId,
 		...getRequestWithdrawalMulticallContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			multicallCalldatas
 		}),
 		account: simulatedAccount,
@@ -30115,7 +30326,7 @@ const useClaimVaultShares = ({ chainId, vaultAddress, queuedDeposits, depositEpo
 
 //#endregion
 //#region src/hypoVault/requestWithdrawal/hooks/use-request-withdrawal.ts
-const useRequestWithdrawal = ({ chainId, vaultAddress, desiredAssets, requestAllAvailableShares = false, sharePrice, walletShares, queuedDeposits, depositEpochStates, currentDepositEpoch, simulationAccount, onWaitSuccess }) => {
+const useRequestWithdrawal = ({ chainId, vaultAddress: vaultAddress$1, desiredAssets, requestAllAvailableShares = false, sharePrice, walletShares, queuedDeposits, depositEpochStates, currentDepositEpoch, simulationAccount, onWaitSuccess }) => {
 	const { address: account } = useAccount();
 	const simulatedAccount = simulationAccount ?? account;
 	const user = simulatedAccount ?? zeroAddress;
@@ -30138,11 +30349,11 @@ const useRequestWithdrawal = ({ chainId, vaultAddress, desiredAssets, requestAll
 		depositEpochStates,
 		currentDepositEpoch
 	]);
-	const canSimulate = multicallCalldatas.length > 0 && vaultAddress !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
+	const canSimulate = multicallCalldatas.length > 0 && vaultAddress$1 !== zeroAddress && simulatedAccount != null && simulatedAccount !== zeroAddress;
 	const simulate = useSimulateContract({
 		chainId,
 		...getRequestWithdrawalMulticallContractConfig({
-			vaultAddress,
+			vaultAddress: vaultAddress$1,
 			multicallCalldatas
 		}),
 		account: simulatedAccount,
@@ -30666,7 +30877,7 @@ function getSdk(client, withWrapper = defaultWrapper) {
 //#endregion
 //#region src/graphqlClient.ts
 const chainToHypoVaultGraphQlAPI = {};
-for (const deployment of Object.values(CHAIN_DEPLOYMENTS)) chainToHypoVaultGraphQlAPI[deployment.chainId] = deployment.subgraphs.hypovault;
+for (const deployment$2 of Object.values(CHAIN_DEPLOYMENTS)) chainToHypoVaultGraphQlAPI[deployment$2.chainId] = deployment$2.subgraphs.hypovault;
 function getHypoVaultGraphQLClient(chainId) {
 	const apiUrl = chainToHypoVaultGraphQlAPI[chainId];
 	if (apiUrl === void 0) throw new Error(`Unsupported HypoVault subgraph chainId: ${chainId}`);
@@ -30680,7 +30891,7 @@ function parseTimestampSec(value) {
 	const parsed = Number(value);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
-async function fetchFirstDepositTimestampForVault({ graphClient, vaultAddress }) {
+async function fetchFirstDepositTimestampForVault({ graphClient, vaultAddress: vaultAddress$1 }) {
 	const response = await graphClient.request(`
       query FirstVaultDepositTimestamp($hypoVault: String!) {
         depositExecuteds(
@@ -30714,7 +30925,7 @@ async function fetchFirstDepositTimestampForVault({ graphClient, vaultAddress })
           }
         }
       }
-    `, { hypoVault: vaultAddress.toLowerCase() });
+    `, { hypoVault: vaultAddress$1.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);
@@ -30723,8 +30934,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) => {
-		const vaultAddressLower = vaultAddress.toLowerCase();
+	const entries = await Promise.all(vaultAddresses.map(async (vaultAddress$1) => {
+		const vaultAddressLower = vaultAddress$1.toLowerCase();
 		const timestamp = await fetchFirstDepositTimestampForVault({
 			graphClient,
 			vaultAddress: vaultAddressLower
@@ -30838,85 +31049,85 @@ function getStaleOracleStateOverrideForAccountant(accountantAddress) {
 //#endregion
 //#region src/hypoVault/sharePrice/strategies.ts
 const DEFAULT_MANAGER_INPUT = "0x";
-function buildVaultStrategyKey(chainId, vaultAddress) {
-	return `${chainId}:${vaultAddress.toLowerCase()}`;
+function buildVaultStrategyKey(chainId, vaultAddress$1) {
+	return `${chainId}:${vaultAddress$1.toLowerCase()}`;
 }
 function resolveChainWethAddress(chainId) {
-	let deployment;
+	let deployment$2;
 	try {
-		deployment = requireChainDeployment(chainId);
+		deployment$2 = requireChainDeployment(chainId);
 	} catch {
 		return void 0;
 	}
-	const wethVaultAddress = deployment.hypovault.vaults.wethPlpVault;
+	const wethVaultAddress = deployment$2.hypovault.vaults.wethPlpVault;
 	return getHypoVaultConfigForVault(wethVaultAddress, chainId)?.addresses?.underlyingToken;
 }
-function getPlpManagerAddress(chainId, vaultAddress) {
-	return getHypoVaultConfigForVault(vaultAddress, chainId)?.addresses?.hypoVaultManagerWithMerkleVerification ?? null;
+function getPlpManagerAddress(chainId, vaultAddress$1) {
+	return getHypoVaultConfigForVault(vaultAddress$1, chainId)?.addresses?.hypoVaultManagerWithMerkleVerification ?? null;
 }
-async function getPlpPoolInfosAtBlock({ chainId, client, vaultAddress, blockNumber }) {
+async function getPlpPoolInfosAtBlock({ chainId, client, vaultAddress: vaultAddress$1, blockNumber }) {
 	return resolveVaultPoolInfosAtBlock({
 		viemClient: client,
 		chainId,
-		vaultAddress,
+		vaultAddress: vaultAddress$1,
 		blockNumber
 	});
 }
 function createPlpManagerInputStrategy(minBlock) {
 	return {
 		enabledMetrics: ["nav"],
-		resolveCandidates: async ({ chainId, vault }) => {
-			const vaultAddress = vault.id;
-			const poolInfos = getVaultCandidatePoolInfos(vaultAddress, chainId);
+		resolveCandidates: async ({ chainId, vault: vault$2 }) => {
+			const vaultAddress$1 = vault$2.id;
+			const poolInfos = getVaultCandidatePoolInfos(vaultAddress$1, chainId);
 			if (poolInfos.length === 0) return [];
 			return resolveVaultHistoricalCandidatesByPool({
 				chainId,
-				vaultAddress,
-				managerAddress: getPlpManagerAddress(chainId, vaultAddress),
+				vaultAddress: vaultAddress$1,
+				managerAddress: getPlpManagerAddress(chainId, vaultAddress$1),
 				poolInfos
 			});
 		},
-		recoverCandidates: async ({ chainId, client, vault, blockNumber, fromBlock, candidates }) => {
-			const vaultAddress = vault.id;
+		recoverCandidates: async ({ chainId, client, vault: vault$2, blockNumber, fromBlock, candidates }) => {
+			const vaultAddress$1 = vault$2.id;
 			return recoverVaultCandidateTokenIdsByPool({
 				viemClient: client,
 				chainId,
-				vaultAddress,
+				vaultAddress: vaultAddress$1,
 				candidatesByPool: candidates,
 				poolInfos: await getPlpPoolInfosAtBlock({
 					chainId,
 					client,
-					vaultAddress,
+					vaultAddress: vaultAddress$1,
 					blockNumber
 				}),
 				blockNumber,
 				fromBlock
 			});
 		},
-		managerInputProvider: async ({ chainId, client, vault, blockNumber, candidates }) => {
-			const vaultAddress = vault.id;
+		managerInputProvider: async ({ chainId, client, vault: vault$2, blockNumber, candidates }) => {
+			const vaultAddress$1 = vault$2.id;
 			if (minBlock !== void 0 && blockNumber < minBlock) throw new VaultApyPreInceptionBlockError({
 				blockNumber,
 				minBlockNumber: minBlock,
-				context: `PLP manager input for vault ${vault.id}`
+				context: `PLP manager input for vault ${vault$2.id}`
 			});
 			const poolInfos = await getPlpPoolInfosAtBlock({
 				chainId,
 				client,
-				vaultAddress,
+				vaultAddress: vaultAddress$1,
 				blockNumber
 			});
 			if (poolInfos.length === 0) return DEFAULT_MANAGER_INPUT;
 			const tokenIds = candidates === void 0 ? await resolveVaultTokenIdsByPool({
 				viemClient: client,
 				chainId,
-				vaultAddress,
-				managerAddress: getPlpManagerAddress(chainId, vaultAddress),
+				vaultAddress: vaultAddress$1,
+				managerAddress: getPlpManagerAddress(chainId, vaultAddress$1),
 				poolInfos,
 				verificationBlockNumber: blockNumber
 			}) : await verifyVaultOpenTokenIdsAtBlock({
 				viemClient: client,
-				vaultAddress,
+				vaultAddress: vaultAddress$1,
 				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}`);
@@ -30932,7 +31143,7 @@ function createPlpManagerInputStrategy(minBlock) {
 				viemClient: client,
 				poolInfos,
 				tokenIds,
-				underlyingToken: vault.underlyingToken.id,
+				underlyingToken: vault$2.underlyingToken.id,
 				...wethAddress === void 0 ? {} : { wethAddress },
 				blockNumber
 			});
@@ -30956,19 +31167,20 @@ const strategyOverridesByVaultKey = {
 	[buildVaultStrategyKey(MAINNET_CHAIN_ID, MainnetWETHPLPVaultPoolInfos.vaultAddress)]: createPlpManagerInputStrategy(),
 	[buildVaultStrategyKey(BASE_CHAIN_ID, BaseUSDCPLPVaultPoolInfos.vaultAddress)]: createPlpManagerInputStrategy(),
 	[buildVaultStrategyKey(BASE_CHAIN_ID, BaseWETHPLPVaultPoolInfos.vaultAddress)]: createPlpManagerInputStrategy(),
+	[buildVaultStrategyKey(ROBINHOOD_CHAIN_ID, RobinhoodUSDGPLPVaultPoolInfos.vaultAddress)]: createPlpManagerInputStrategy(),
 	[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 }) {
-	const key = buildVaultStrategyKey(chainId, vaultAddress);
+function getVaultApyStrategy({ chainId, vaultAddress: vaultAddress$1 }) {
+	const key = buildVaultStrategyKey(chainId, vaultAddress$1);
 	return strategyOverridesByVaultKey[key] ?? defaultStrategy;
 }
-function setVaultApyStrategyOverride({ chainId, vaultAddress, strategy }) {
-	const key = buildVaultStrategyKey(chainId, vaultAddress);
+function setVaultApyStrategyOverride({ chainId, vaultAddress: vaultAddress$1, strategy }) {
+	const key = buildVaultStrategyKey(chainId, vaultAddress$1);
 	strategyOverridesByVaultKey[key] = strategy;
 }
-function clearVaultApyStrategyOverride({ chainId, vaultAddress }) {
-	const key = buildVaultStrategyKey(chainId, vaultAddress);
+function clearVaultApyStrategyOverride({ chainId, vaultAddress: vaultAddress$1 }) {
+	const key = buildVaultStrategyKey(chainId, vaultAddress$1);
 	delete strategyOverridesByVaultKey[key];
 }
 
@@ -30987,17 +31199,17 @@ function getAssetsDepositedFromDepositEpochState(value) {
 	}
 	return null;
 }
-async function fetchVaultSharePriceSnapshot({ client, vault, chainId, windowLabel, blockNumber, readContractFn, candidates, includeTokenIdsInDiagnostics = false }) {
-	const vaultAddress = vault.id;
-	const accountantAddress = vault.accountant;
-	const underlyingTokenAddress = vault.underlyingToken.id;
+async function fetchVaultSharePriceSnapshot({ client, vault: vault$2, chainId, windowLabel, blockNumber, readContractFn, candidates, includeTokenIdsInDiagnostics = false }) {
+	const vaultAddress$1 = vault$2.id;
+	const accountantAddress = vault$2.accountant;
+	const underlyingTokenAddress = vault$2.underlyingToken.id;
 	const strategy = getVaultApyStrategy({
 		chainId,
-		vaultAddress
+		vaultAddress: vaultAddress$1
 	});
 	const managerInputProviderResult = await strategy.managerInputProvider({
 		chainId,
-		vault,
+		vault: vault$2,
 		client,
 		blockNumber,
 		candidates
@@ -31025,7 +31237,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault, chainId, windowLabe
 		readWithContext({
 			callName: "depositEpoch",
 			request: {
-				address: vaultAddress,
+				address: vaultAddress$1,
 				abi: HypoVaultAbi,
 				functionName: "depositEpoch",
 				blockNumber
@@ -31034,7 +31246,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault, chainId, windowLabe
 		readWithContext({
 			callName: "reservedWithdrawalAssets",
 			request: {
-				address: vaultAddress,
+				address: vaultAddress$1,
 				abi: HypoVaultAbi,
 				functionName: "reservedWithdrawalAssets",
 				blockNumber
@@ -31043,7 +31255,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault, chainId, windowLabe
 		readWithContext({
 			callName: "totalSupply",
 			request: {
-				address: vaultAddress,
+				address: vaultAddress$1,
 				abi: HypoVaultAbi,
 				functionName: "totalSupply",
 				blockNumber
@@ -31051,11 +31263,11 @@ async function fetchVaultSharePriceSnapshot({ client, vault, chainId, windowLabe
 		})
 	]);
 	const depositEpoch = toBigInt(depositEpochRaw);
-	if (depositEpoch === null) throw new Error(`Unexpected depositEpoch output type for vault ${vault.id}`);
+	if (depositEpoch === null) throw new Error(`Unexpected depositEpoch output type for vault ${vault$2.id}`);
 	const depositEpochStateRaw = await readWithContext({
 		callName: "depositEpochState",
 		request: {
-			address: vaultAddress,
+			address: vaultAddress$1,
 			abi: HypoVaultAbi,
 			functionName: "depositEpochState",
 			args: [depositEpoch],
@@ -31065,7 +31277,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault, chainId, windowLabe
 	const reservedWithdrawalAssets = toBigInt(reservedWithdrawalAssetsRaw);
 	const shares = toBigInt(sharesRaw);
 	const assetsDeposited = getAssetsDepositedFromDepositEpochState(depositEpochStateRaw);
-	if (reservedWithdrawalAssets === null || shares === null || assetsDeposited === null) throw new Error(`Unexpected readContract output types for vault ${vault.id}`);
+	if (reservedWithdrawalAssets === null || shares === null || assetsDeposited === null) throw new Error(`Unexpected readContract output types for vault ${vault$2.id}`);
 	let nav = null;
 	let navSource = "computeNAV";
 	const staleOracleStateOverride = getStaleOracleStateOverrideForAccountant(accountantAddress);
@@ -31074,7 +31286,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault, chainId, windowLabe
 		abi: PanopticVaultAccountantAbi,
 		functionName: "computeNAV",
 		args: [
-			vaultAddress,
+			vaultAddress$1,
 			underlyingTokenAddress,
 			managerInput
 		],
@@ -31100,7 +31312,7 @@ async function fetchVaultSharePriceSnapshot({ client, vault, chainId, windowLabe
 		nav = toBigInt(navRawWithOverride);
 		navSource = "computeNAVStateOverride";
 	}
-	if (nav === null) throw new Error(`Unexpected computeNAV output type for vault ${vault.id}`);
+	if (nav === null) throw new Error(`Unexpected computeNAV output type for vault ${vault$2.id}`);
 	const sharePrice = computeSharePriceFromNavSnapshot({
 		nav,
 		assetsDeposited,
@@ -31163,43 +31375,43 @@ function createVaultSharePriceProcessor({ chainId, client, candidateRefreshSecon
 	const candidateCache = new Map();
 	const lastTrustedBlockByVault = new Map();
 	const seededVaults = new Set();
-	async function getCandidates({ strategy, vault, blockTimestamp }) {
+	async function getCandidates({ strategy, vault: vault$2, blockTimestamp }) {
 		if (strategy.resolveCandidates === void 0) return void 0;
-		const cached = candidateCache.get(vault.id);
+		const cached = candidateCache.get(vault$2.id);
 		if (cached !== void 0 && blockTimestamp - cached.fetchedAtChainTime < candidateRefreshSeconds) return cached.candidates;
 		const candidates = await strategy.resolveCandidates({
 			chainId,
-			vault,
+			vault: vault$2,
 			client
 		});
-		candidateCache.set(vault.id, {
+		candidateCache.set(vault$2.id, {
 			candidates,
 			fetchedAtChainTime: blockTimestamp
 		});
 		return candidates;
 	}
-	async function getRecoveryFromBlock({ vault, recoveryFallbackBlock, loadLastTrustedBlock }) {
-		if (!seededVaults.has(vault.id)) {
+	async function getRecoveryFromBlock({ vault: vault$2, recoveryFallbackBlock, loadLastTrustedBlock }) {
+		if (!seededVaults.has(vault$2.id)) {
 			const persistedBlock = await loadLastTrustedBlock();
-			if (persistedBlock !== void 0) lastTrustedBlockByVault.set(vault.id, persistedBlock);
-			seededVaults.add(vault.id);
+			if (persistedBlock !== void 0) lastTrustedBlockByVault.set(vault$2.id, persistedBlock);
+			seededVaults.add(vault$2.id);
 		}
-		return lastTrustedBlockByVault.get(vault.id) ?? recoveryFallbackBlock;
+		return lastTrustedBlockByVault.get(vault$2.id) ?? recoveryFallbackBlock;
 	}
-	return { async process({ vault, strategy, blockNumber, blockTimestamp, recoveryFallbackBlock, loadLastTrustedBlock, readContractFn, windowLabel = "series" }) {
+	return { async process({ vault: vault$2, strategy, blockNumber, blockTimestamp, recoveryFallbackBlock, loadLastTrustedBlock, readContractFn, windowLabel = "series" }) {
 		const candidates = await getCandidates({
 			strategy,
-			vault,
+			vault: vault$2,
 			blockTimestamp
 		});
 		const recoveryFromBlock = await getRecoveryFromBlock({
-			vault,
+			vault: vault$2,
 			recoveryFallbackBlock,
 			loadLastTrustedBlock
 		});
 		const result = await fetchVaultSharePriceSnapshotWithCandidateRecovery({
 			client,
-			vault,
+			vault: vault$2,
 			chainId,
 			windowLabel,
 			blockNumber,
@@ -31207,12 +31419,12 @@ function createVaultSharePriceProcessor({ chainId, client, candidateRefreshSecon
 			candidates,
 			recoveryFromBlock
 		});
-		if (result.candidates !== void 0 && result.candidates !== candidates) candidateCache.set(vault.id, {
+		if (result.candidates !== void 0 && result.candidates !== candidates) candidateCache.set(vault$2.id, {
 			candidates: result.candidates,
 			fetchedAtChainTime: blockTimestamp
 		});
 		const status = statusForVaultSharePriceSnapshot(result.snapshot);
-		if (isTrustedVaultSharePriceStatus(status)) lastTrustedBlockByVault.set(vault.id, blockNumber);
+		if (isTrustedVaultSharePriceStatus(status)) lastTrustedBlockByVault.set(vault$2.id, blockNumber);
 		return {
 			snapshot: result.snapshot,
 			status
@@ -32029,5 +32241,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, RescueDistributorAbi, 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, 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, getAlchemyRpcUrl, getAlchemyWsRpcUrl, getCancelDepositContractConfig, getChainDeployment, getEthUsdcMarket, getExecuteWithdrawalContractConfig, getExecuteWithdrawalMulticallContractConfig, getHypoVaultConfigForVault, getHypoVaultGraphQLClient, getIrmCurrent, getIrmCurve, getLendingAllocationRows, getMainnetV3AuthorizationArtifactsAtBlock, getMainnetV3AuthorizationGenerations, getMainnetVaultManagerRootAtBlock, getMainnetVaultManagerRootHistory, getMainnetVaultPoolConfigurationAtBlock, getMainnetVaultPoolConfigurationHistory, getMinQueuedDepositEpoch, getProofsFromDigests, getProofsUsingTree, getRequestDepositContractConfig, getRequestWithdrawalContractConfig, getRequestWithdrawalMulticallContractConfig, getStaleOracleOverrideBytecodeForAccountant, getStaleOracleStateOverrideForAccountant, 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_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, getAlchemyRpcUrl, getAlchemyWsRpcUrl, getCancelDepositContractConfig, getChainDeployment, getEthUsdcMarket, getExecuteWithdrawalContractConfig, getExecuteWithdrawalMulticallContractConfig, getHypoVaultConfigForVault, getHypoVaultGraphQLClient, getIrmCurrent, getIrmCurve, getLendingAllocationRows, getMainnetV3AuthorizationArtifactsAtBlock, getMainnetV3AuthorizationGenerations, getMainnetVaultManagerRootAtBlock, getMainnetVaultManagerRootHistory, getMainnetVaultPoolConfigurationAtBlock, getMainnetVaultPoolConfigurationHistory, getMinQueuedDepositEpoch, getProofsFromDigests, getProofsUsingTree, getRequestDepositContractConfig, getRequestWithdrawalContractConfig, getRequestWithdrawalMulticallContractConfig, getSpyUsdgMarket, getStaleOracleOverrideBytecodeForAccountant, getStaleOracleStateOverrideForAccountant, 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 };
 //# sourceMappingURL=index.js.map