otto-intel-mcp 0.1.2 → 0.1.4

package/dist/vendor/lp-v3/lp-v3-contract.js

@@ -0,0 +1,137 @@
+import { bytesToHex, keccak256, parseAbi, stringToHex } from 'viem';
+import { z } from 'zod';
+/** Public runtime bytecode digests, represented as bytes for portable package
+ * declarations. Runtime values and exact z.literal checks remain unchanged.
+ * These are public chain facts, never credentials or configurable policy.
+ */
+function publicCodeHash(bytes) {
+    if (bytes.length !== 32 || bytes.some(byte => !Number.isInteger(byte) || byte < 0 || byte > 255))
+        throw new Error('LP_INVALID_PUBLIC_CODE_HASH');
+    return bytesToHex(Uint8Array.from(bytes));
+}
+// Canonical Base deployment and runtime code read at block 51211952, 2026-09-12.
+// Proxy upgrades deliberately fail closed until separately reviewed and repinned.
+export const LP_V3_BASE = Object.freeze({
+    chainId: 8453,
+    factory: '0x33128a8fc17869897dce68ed026d694621f6fdfd',
+    manager: '0x03a520b32c04bf3beef7beb72e919cf822ed34f1',
+    token0: '0x4200000000000000000000000000000000000006', // WETH, 18 decimals
+    token1: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913', // native USDC, 6 decimals
+    factoryCodeHash: publicCodeHash([
+        0x95, 0x70, 0x7a, 0x4a, 0xc7, 0x1f, 0x20, 0x18, 0x1a, 0x63, 0xef, 0x7d, 0x18, 0x0e, 0x3c, 0x62,
+        0x5b, 0xe5, 0xd2, 0x0f, 0xc8, 0xf6, 0xf9, 0x80, 0xbe, 0xfa, 0x96, 0x6b, 0xad, 0x56, 0x81, 0x32,
+    ]),
+    managerCodeHash: publicCodeHash([
+        0x91, 0x77, 0xa1, 0x17, 0x68, 0x99, 0x6e, 0x8f, 0x95, 0x1e, 0x0f, 0x00, 0x13, 0xd7, 0x16, 0x51,
+        0x34, 0x17, 0x8b, 0x15, 0xb2, 0x1f, 0xb9, 0x91, 0x61, 0x08, 0xf9, 0x95, 0xe6, 0xc5, 0x64, 0xbf,
+    ]),
+    token0CodeHash: publicCodeHash([
+        0x8a, 0x3a, 0x1f, 0x6a, 0x9f, 0x9d, 0xce, 0x63, 0x31, 0x17, 0xad, 0xee, 0x5b, 0x45, 0x82, 0x45,
+        0x83, 0x5a, 0x86, 0x45, 0xa8, 0xc8, 0x72, 0x6a, 0x26, 0x38, 0x2a, 0x46, 0x22, 0x50, 0x8b, 0x1c,
+    ]),
+    token1CodeHash: publicCodeHash([
+        0xa6, 0x70, 0x5a, 0x10, 0xbb, 0x75, 0x6b, 0x5d, 0xea, 0x14, 0x45, 0x91, 0x11, 0x8b, 0xe7, 0x7d,
+        0x7a, 0xf0, 0xc3, 0xee, 0xe3, 0xbf, 0x2d, 0xfe, 0x25, 0x83, 0xdc, 0xb0, 0x36, 0x4f, 0xef, 0xab,
+    ]),
+    usdcImplementationSlot: keccak256(stringToHex('org.zeppelinos.proxy.implementation')),
+    usdcImplementation: '0x2ce6311ddae708829bc0784c967b7d77d19fd779',
+    usdcImplementationCodeHash: publicCodeHash([
+        0x11, 0xb7, 0x5a, 0x23, 0x79, 0x97, 0xab, 0x83, 0x28, 0xf6, 0x5b, 0x2d, 0x5a, 0x55, 0xc1, 0x0f,
+        0x03, 0x46, 0xd0, 0xa1, 0x75, 0x74, 0x1e, 0xd4, 0x2d, 0xdf, 0x4f, 0x2c, 0x66, 0xb9, 0xe8, 0x73,
+    ]),
+});
+export const lpAddress = z.string().regex(/^0x[0-9a-f]{40}$/).refine(v => !/^0x0{40}$/.test(v));
+export const lpHash = z.string().regex(/^0x[0-9a-f]{64}$/).refine(v => !/^0x0{64}$/.test(v));
+export const lpUint = (bits = 256) => z.string().regex(/^(0|[1-9][0-9]{0,77})$/).refine(v => BigInt(v) < 1n << BigInt(bits));
+const uint = lpUint(), uint128 = lpUint(128);
+const tick = z.number().int().min(-887272).max(887272);
+const pair = z.tuple([uint, uint]);
+const common = {
+    schemaVersion: z.literal(1), protocol: z.literal('uniswap-v3'), chainId: z.literal(8453),
+    // Unique authenticated operation ID. The execution owner's durable journal enforces replay exclusion.
+    operationId: z.string().regex(/^[a-zA-Z0-9_-]{16,96}$/),
+    account: lpAddress, recipient: lpAddress,
+    manager: z.literal(LP_V3_BASE.manager), factory: z.literal(LP_V3_BASE.factory), pool: lpAddress,
+    token0: z.literal(LP_V3_BASE.token0), token1: z.literal(LP_V3_BASE.token1),
+    fee: z.union([z.literal(100), z.literal(500), z.literal(3000), z.literal(10000)]),
+    tickLower: tick, tickUpper: tick,
+    deadline: z.number().int().positive().safe(),
+};
+export const lpV3IntentSchema = z.discriminatedUnion('action', [
+    z.object({ ...common, action: z.literal('mint'), amountDesired: pair, amountMin: pair }).strict(),
+    z.object({ ...common, action: z.literal('increase'), tokenId: uint, amountDesired: pair, amountMin: pair }).strict(),
+    z.object({ ...common, action: z.literal('decrease'), tokenId: uint, liquidity: uint128, amountMin: pair }).strict(),
+    // collect has no onchain deadline/minimum. The sender must check deadline before signing;
+    // output floors are settlement postconditions, not an atomic slippage guarantee.
+    z.object({ ...common, action: z.literal('collect'), tokenId: uint, amountMax: z.tuple([uint128, uint128]), amountMin: pair }).strict(),
+]);
+export const lpV3PositionSchema = z.object({
+    tokenId: uint, owner: lpAddress, token0: lpAddress, token1: lpAddress,
+    fee: z.number().int(), tickLower: tick, tickUpper: tick, liquidity: uint128,
+    tokensOwed: z.tuple([uint128, uint128]),
+}).strict();
+export const lpV3ChainEvidenceSchema = z.object({
+    schemaVersion: z.literal(1), chainId: z.literal(8453),
+    blockNumber: uint, blockHash: lpHash, blockTimestamp: z.number().int().positive().safe(),
+    observedAt: z.number().int().positive().safe(), canonical: z.literal(true),
+    account: lpAddress, accountCode: z.literal('0x'), balances: pair, allowances: pair,
+    manager: z.literal(LP_V3_BASE.manager), managerFactory: z.literal(LP_V3_BASE.factory),
+    factory: z.literal(LP_V3_BASE.factory), factoryPool: lpAddress,
+    factoryCodeHash: z.literal(LP_V3_BASE.factoryCodeHash), managerCodeHash: z.literal(LP_V3_BASE.managerCodeHash),
+    token0CodeHash: z.literal(LP_V3_BASE.token0CodeHash), token1CodeHash: z.literal(LP_V3_BASE.token1CodeHash),
+    usdcImplementation: z.literal(LP_V3_BASE.usdcImplementation),
+    usdcImplementationCodeHash: z.literal(LP_V3_BASE.usdcImplementationCodeHash),
+    usdcPaused: z.literal(false), accountBlacklisted: z.literal(false), managerBlacklisted: z.literal(false),
+    pool: lpAddress, poolFactory: z.literal(LP_V3_BASE.factory),
+    token0: z.literal(LP_V3_BASE.token0), token1: z.literal(LP_V3_BASE.token1),
+    fee: z.number().int(), tickSpacing: z.number().int().positive(),
+    tick, sqrtPriceX96: lpUint(160), unlocked: z.literal(true),
+    position: lpV3PositionSchema.nullable(),
+}).strict();
+export const lpV3CallSchema = z.object({
+    step: z.enum(['approve', 'mutation', 'cleanup']), tokenIndex: z.union([z.literal(0), z.literal(1)]).nullable(),
+    chainId: z.literal(8453), from: lpAddress, to: lpAddress, value: z.literal('0'),
+    data: z.string().regex(/^0x[0-9a-f]+$/),
+}).strict();
+export const lpV3SigningSupportSchema = z.enum(['HOST_GATES_REQUIRED', 'BLOCKED_ATOMIC_NFT_OWNER_GUARD', 'BLOCKED_ATOMIC_COLLECTION_GUARD']);
+export const lpV3PreparedPlanSchema = z.object({
+    schemaVersion: z.literal(1), kind: z.literal('lp-v3'), intent: lpV3IntentSchema,
+    signingSupport: lpV3SigningSupportSchema,
+    intentCommitment: lpHash, calls: z.array(lpV3CallSchema).min(1).max(5),
+    // Economic state read at preparation; verification independently refreshes it.
+    preparedBlock: z.object({ number: uint, hash: lpHash }).strict(),
+    planCommitment: lpHash,
+}).strict();
+export const LP_V3_NPM_ABI = parseAbi([
+    'function mint((address token0,address token1,uint24 fee,int24 tickLower,int24 tickUpper,uint256 amount0Desired,uint256 amount1Desired,uint256 amount0Min,uint256 amount1Min,address recipient,uint256 deadline) params) payable returns (uint256 tokenId,uint128 liquidity,uint256 amount0,uint256 amount1)',
+    'function increaseLiquidity((uint256 tokenId,uint256 amount0Desired,uint256 amount1Desired,uint256 amount0Min,uint256 amount1Min,uint256 deadline) params) payable returns (uint128 liquidity,uint256 amount0,uint256 amount1)',
+    'function decreaseLiquidity((uint256 tokenId,uint128 liquidity,uint256 amount0Min,uint256 amount1Min,uint256 deadline) params) payable returns (uint256 amount0,uint256 amount1)',
+    'function collect((uint256 tokenId,address recipient,uint128 amount0Max,uint128 amount1Max) params) payable returns (uint256 amount0,uint256 amount1)',
+    'event IncreaseLiquidity(uint256 indexed tokenId,uint128 liquidity,uint256 amount0,uint256 amount1)',
+    'event DecreaseLiquidity(uint256 indexed tokenId,uint128 liquidity,uint256 amount0,uint256 amount1)',
+    'event Collect(uint256 indexed tokenId,address recipient,uint256 amount0,uint256 amount1)',
+    'event Transfer(address indexed from,address indexed to,uint256 indexed tokenId)',
+]);
+export const LP_V3_ERC20_ABI = parseAbi([
+    'function approve(address spender,uint256 amount) returns (bool)',
+    'event Transfer(address indexed from,address indexed to,uint256 value)',
+]);
+export function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (value !== null && typeof value === 'object')
+        return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(',')}}`;
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+        throw new Error('LP_UNSERIALIZABLE_VALUE');
+    return encoded;
+}
+export const commitment = (value) => keccak256(stringToHex(canonicalJson(value)));
+export function deepFreeze(value) {
+    if (value && typeof value === 'object') {
+        Object.values(value).forEach(deepFreeze);
+        Object.freeze(value);
+    }
+    return value;
+}
+//# sourceMappingURL=lp-v3-contract.js.map

package/dist/vendor/lp-v3/lp-v3-evidence.d.ts

@@ -0,0 +1,25 @@
+import { type LpV3ChainEvidence, type LpV3Intent } from './lp-v3-contract.js';
+export interface LpV3ReadRequest {
+    method: 'eth_chainId' | 'eth_getBlockByNumber' | 'eth_getCode' | 'eth_getStorageAt' | 'eth_call';
+    params?: readonly unknown[];
+}
+/** Trusted host dependency, never a caller-supplied evidence/API object. */
+export interface LpV3ReadClient {
+    request(request: LpV3ReadRequest): Promise<unknown>;
+}
+export interface LpV3EvidenceOptions {
+    client?: LpV3ReadClient;
+    /** Trusted host clock, in integer Unix seconds. */
+    nowSeconds?: () => number;
+    /** May tighten the default 60 seconds; hard maximum 60 seconds. */
+    maxBlockAgeSeconds?: number;
+}
+export declare class LpV3EvidenceError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+/** Read-only Base evidence. EIP-1898 binds every state read to one canonical hash.
+ * Unsupported hash-based RPC reads fail closed; there is no latest-state fallback.
+ * This is a point-in-time RPC observation, not finality or permission to execute.
+ */
+export declare function collectLpV3ChainEvidence(input: LpV3Intent, options?: LpV3EvidenceOptions): Promise<LpV3ChainEvidence>;

package/dist/vendor/lp-v3/lp-v3-evidence.js

@@ -0,0 +1,168 @@
+import { createPublicClient, decodeFunctionResult, encodeFunctionData, http, keccak256, parseAbi } from 'viem';
+import { base } from 'viem/chains';
+import { LP_V3_BASE, lpV3ChainEvidenceSchema, lpV3IntentSchema, lpV3PositionSchema } from './lp-v3-contract.js';
+import { MAX_TICK, MIN_TICK, sqrtPriceAtTick } from './v4-math.js';
+const READ_ABI = parseAbi([
+    'function factory() view returns (address)', 'function WETH9() view returns (address)',
+    'function getPool(address token0,address token1,uint24 fee) view returns (address)',
+    'function feeAmountTickSpacing(uint24 fee) view returns (int24)',
+    'function token0() view returns (address)', 'function token1() view returns (address)',
+    'function fee() view returns (uint24)', 'function tickSpacing() view returns (int24)',
+    'function slot0() view returns (uint160 sqrtPriceX96,int24 tick,uint16 observationIndex,uint16 observationCardinality,uint16 observationCardinalityNext,uint8 feeProtocol,bool unlocked)',
+    'function balanceOf(address owner) view returns (uint256)',
+    'function allowance(address owner,address spender) view returns (uint256)',
+    'function decimals() view returns (uint8)', 'function paused() view returns (bool)',
+    'function isBlacklisted(address account) view returns (bool)',
+    'function ownerOf(uint256 tokenId) view returns (address)',
+    'function positions(uint256 tokenId) view returns (uint96 nonce,address operator,address token0,address token1,uint24 fee,int24 tickLower,int24 tickUpper,uint128 liquidity,uint256 feeGrowthInside0LastX128,uint256 feeGrowthInside1LastX128,uint128 tokensOwed0,uint128 tokensOwed1)',
+]);
+export class LpV3EvidenceError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'LpV3EvidenceError';
+    }
+}
+function requireState(condition, code) {
+    if (!condition)
+        throw new LpV3EvidenceError(code);
+}
+function address(value) {
+    requireState(typeof value === 'string' && /^0x[0-9a-fA-F]{40}$/.test(value) && !/^0x0{40}$/.test(value), 'LP_V3_INVALID_ADDRESS');
+    return value.toLowerCase();
+}
+function hex(value) {
+    requireState(typeof value === 'string' && /^0x(?:[0-9a-fA-F]{2})*$/.test(value), 'LP_V3_INVALID_RPC_DATA');
+    return value.toLowerCase();
+}
+function quantity(value) {
+    requireState(typeof value === 'string' && /^0x(?:0|[1-9a-fA-F][0-9a-fA-F]*)$/.test(value), 'LP_V3_INVALID_RPC_QUANTITY');
+    return BigInt(value);
+}
+function uint(value, bits = 256) {
+    requireState(typeof value === 'bigint' && value >= 0n && value < 1n << BigInt(bits), 'LP_V3_INVALID_CONTRACT_UINT');
+    return value;
+}
+function integer(value, minimum, maximum) {
+    requireState(typeof value === 'number' && Number.isSafeInteger(value) && value >= minimum && value <= maximum, 'LP_V3_INVALID_CONTRACT_INTEGER');
+    return value;
+}
+function tuple(value, length) {
+    requireState(Array.isArray(value) && value.length === length, 'LP_V3_INVALID_CONTRACT_TUPLE');
+    return value;
+}
+function block(value) {
+    requireState(value !== null && typeof value === 'object', 'LP_V3_BLOCK_UNAVAILABLE');
+    const raw = value, number = quantity(raw.number), timestamp = quantity(raw.timestamp), hash = hex(raw.hash);
+    requireState(hash.length === 66 && !/^0x0{64}$/.test(hash) && timestamp > 0n && timestamp <= BigInt(Number.MAX_SAFE_INTEGER), 'LP_V3_INVALID_BLOCK');
+    return { number, hash, timestamp: Number(timestamp) };
+}
+/** Read-only Base evidence. EIP-1898 binds every state read to one canonical hash.
+ * Unsupported hash-based RPC reads fail closed; there is no latest-state fallback.
+ * This is a point-in-time RPC observation, not finality or permission to execute.
+ */
+export async function collectLpV3ChainEvidence(input, options = {}) {
+    try {
+        const parsed = lpV3IntentSchema.safeParse(input);
+        requireState(parsed.success, 'LP_V3_INVALID_INTENT');
+        const intent = parsed.data, pins = LP_V3_BASE;
+        const maxAge = options.maxBlockAgeSeconds ?? 60;
+        requireState(Number.isSafeInteger(maxAge) && maxAge > 0 && maxAge <= 60, 'LP_V3_INVALID_FRESHNESS_LIMIT');
+        const now = options.nowSeconds ?? (() => Math.floor(Date.now() / 1000));
+        const clock = () => integer(now(), 1, Number.MAX_SAFE_INTEGER);
+        const startedAt = clock();
+        const publicClient = options.client ? null : createPublicClient({ chain: base, transport: http('https://mainnet.base.org', { timeout: 15_000, retryCount: 1 }) });
+        // The constrained raw interface preserves EIP-1898 for all three state methods.
+        const request = publicClient?.request;
+        // Bound concurrency on the default public endpoint. A failed read also
+        // rejects its queued successors; no incomplete evidence can be returned.
+        let pending = Promise.resolve();
+        const client = options.client ?? { request: args => (pending = pending.then(() => request(args))) };
+        const chain = async () => requireState(quantity(await client.request({ method: 'eth_chainId' })) === BigInt(pins.chainId), 'LP_V3_RPC_CHAIN_MISMATCH');
+        await chain();
+        const anchor = block(await client.request({ method: 'eth_getBlockByNumber', params: ['latest', false] }));
+        const fresh = (time) => requireState(anchor.timestamp <= time && time - anchor.timestamp <= maxAge, 'LP_V3_STALE_OR_FUTURE_BLOCK');
+        fresh(clock());
+        const reference = Object.freeze({ blockHash: anchor.hash, requireCanonical: true });
+        const read = async (target, functionName, args) => {
+            const data = encodeFunctionData({ abi: READ_ABI, functionName, args });
+            const result = hex(await client.request({ method: 'eth_call', params: [{ to: target, data }, reference] }));
+            return decodeFunctionResult({ abi: READ_ABI, functionName, data: result });
+        };
+        const getCode = async (target) => hex(await client.request({ method: 'eth_getCode', params: [target, reference] }));
+        const [factoryPoolRaw, factorySpacingRaw, managerFactoryRaw, managerWethRaw, accountCode, implementationStorage] = await Promise.all([
+            read(pins.factory, 'getPool', [pins.token0, pins.token1, intent.fee]),
+            read(pins.factory, 'feeAmountTickSpacing', [intent.fee]),
+            read(pins.manager, 'factory'), read(pins.manager, 'WETH9'), getCode(intent.account),
+            client.request({ method: 'eth_getStorageAt', params: [pins.token1, pins.usdcImplementationSlot, reference] }),
+        ]);
+        const factoryPool = address(factoryPoolRaw), managerFactory = address(managerFactoryRaw);
+        requireState(factoryPool === intent.pool && managerFactory === pins.factory && address(managerWethRaw) === pins.token0, 'LP_V3_DEPLOYMENT_IDENTITY_MISMATCH');
+        requireState(accountCode === '0x', 'LP_V3_EOA_REQUIRED');
+        const storage = hex(implementationStorage);
+        requireState(/^0x0{24}[0-9a-f]{40}$/.test(storage), 'LP_V3_INVALID_USDC_IMPLEMENTATION_SLOT');
+        const usdcImplementation = address(`0x${storage.slice(-40)}`);
+        requireState(usdcImplementation === pins.usdcImplementation, 'LP_V3_USDC_IMPLEMENTATION_CHANGED');
+        const tickSpacing = integer(factorySpacingRaw, 1, 16_383);
+        requireState(intent.tickLower < intent.tickUpper && intent.tickLower % tickSpacing === 0 && intent.tickUpper % tickSpacing === 0, 'LP_V3_INVALID_INTENT_TICKS');
+        const [poolFactoryRaw, token0Raw, token1Raw, feeRaw, spacingRaw, rawSlot, balancesRaw, allowancesRaw, paused, accountBlacklisted, managerBlacklisted, decimals, codes, positionRaw] = await Promise.all([
+            read(factoryPool, 'factory'), read(factoryPool, 'token0'), read(factoryPool, 'token1'),
+            read(factoryPool, 'fee'), read(factoryPool, 'tickSpacing'), read(factoryPool, 'slot0'),
+            Promise.all([pins.token0, pins.token1].map(token => read(token, 'balanceOf', [intent.account]))),
+            Promise.all([pins.token0, pins.token1].map(token => read(token, 'allowance', [intent.account, pins.manager]))),
+            read(pins.token1, 'paused'), read(pins.token1, 'isBlacklisted', [intent.account]), read(pins.token1, 'isBlacklisted', [pins.manager]),
+            Promise.all([pins.token0, pins.token1].map(token => read(token, 'decimals'))),
+            Promise.all([pins.factory, pins.manager, pins.token0, pins.token1, usdcImplementation, factoryPool].map(getCode)),
+            intent.action === 'mint' ? null : Promise.all([read(pins.manager, 'ownerOf', [BigInt(intent.tokenId)]), read(pins.manager, 'positions', [BigInt(intent.tokenId)])]),
+        ]);
+        const poolFactory = address(poolFactoryRaw), token0 = address(token0Raw), token1 = address(token1Raw);
+        const fee = integer(feeRaw, 0, 999_999);
+        requireState(poolFactory === pins.factory && token0 === pins.token0 && token1 === pins.token1 && fee === intent.fee && spacingRaw === tickSpacing, 'LP_V3_POOL_IDENTITY_MISMATCH');
+        requireState(paused === false && accountBlacklisted === false && managerBlacklisted === false, 'LP_V3_USDC_TRANSFER_RESTRICTED');
+        requireState(decimals[0] === 18 && decimals[1] === 6, 'LP_V3_TOKEN_DECIMALS_MISMATCH');
+        const slot = tuple(rawSlot, 7), sqrt = uint(slot[0], 160), tick = integer(slot[1], MIN_TICK, MAX_TICK - 1);
+        requireState(slot[6] === true && sqrt >= sqrtPriceAtTick(MIN_TICK) && sqrt < sqrtPriceAtTick(MAX_TICK), 'LP_V3_UNINITIALIZED_OR_LOCKED_POOL');
+        // Exact downward tick crossings legitimately leave slot0.tick one below the ratio's tick.
+        requireState(sqrt >= sqrtPriceAtTick(tick) && sqrt <= sqrtPriceAtTick(tick + 1), 'LP_V3_INCONSISTENT_POOL_PRICE');
+        const balances = balancesRaw.map(value => uint(value).toString()), allowances = allowancesRaw.map(value => uint(value).toString());
+        let position = null;
+        if (intent.action !== 'mint') {
+            requireState(positionRaw !== null, 'LP_V3_POSITION_UNAVAILABLE');
+            const data = tuple(positionRaw[1], 12);
+            position = lpV3PositionSchema.parse({
+                tokenId: intent.tokenId, owner: address(positionRaw[0]), token0: address(data[2]), token1: address(data[3]),
+                fee: integer(data[4], 0, 999_999), tickLower: integer(data[5], MIN_TICK, MAX_TICK), tickUpper: integer(data[6], MIN_TICK, MAX_TICK),
+                liquidity: uint(data[7], 128).toString(), tokensOwed: [uint(data[10], 128).toString(), uint(data[11], 128).toString()],
+            });
+            requireState(position.owner === intent.account, 'LP_V3_NFT_OWNER_MISMATCH');
+            requireState(position.token0 === token0 && position.token1 === token1 && position.fee === fee && position.tickLower === intent.tickLower && position.tickUpper === intent.tickUpper, 'LP_V3_NFT_POSITION_MISMATCH');
+        }
+        requireState(codes.every(code => code !== '0x'), 'LP_V3_CONTRACT_CODE_UNAVAILABLE');
+        // Re-read the canonical number mapping even though each state call required canonicality.
+        const canonicalBlock = block(await client.request({ method: 'eth_getBlockByNumber', params: [`0x${anchor.number.toString(16)}`, false] }));
+        await chain();
+        requireState(canonicalBlock.number === anchor.number && canonicalBlock.hash === anchor.hash && canonicalBlock.timestamp === anchor.timestamp, 'LP_V3_BLOCK_REORG');
+        const observedAt = clock();
+        requireState(observedAt >= startedAt, 'LP_V3_CLOCK_MOVED_BACKWARDS');
+        fresh(observedAt);
+        const hashes = codes.slice(0, 5).map(code => keccak256(code));
+        const expectedHashes = [pins.factoryCodeHash, pins.managerCodeHash, pins.token0CodeHash, pins.token1CodeHash, pins.usdcImplementationCodeHash];
+        requireState(hashes.every((hash, index) => hash === expectedHashes[index]), 'LP_V3_RUNTIME_CODE_CHANGED');
+        return lpV3ChainEvidenceSchema.parse({
+            schemaVersion: 1, chainId: pins.chainId, blockNumber: anchor.number.toString(), blockHash: anchor.hash,
+            blockTimestamp: anchor.timestamp, observedAt, canonical: true, account: intent.account, accountCode, balances, allowances,
+            manager: pins.manager, managerFactory, factory: pins.factory, factoryPool,
+            factoryCodeHash: hashes[0], managerCodeHash: hashes[1], token0CodeHash: hashes[2], token1CodeHash: hashes[3],
+            usdcImplementation, usdcImplementationCodeHash: hashes[4], usdcPaused: paused, accountBlacklisted, managerBlacklisted,
+            pool: factoryPool, poolFactory, token0, token1, fee, tickSpacing, tick, sqrtPriceX96: sqrt.toString(), unlocked: slot[6], position,
+        });
+    }
+    catch (error) {
+        // RPC messages can contain endpoint credentials. Never include the underlying error.
+        if (error instanceof LpV3EvidenceError)
+            throw error;
+        throw new LpV3EvidenceError('LP_V3_REQUIRED_CHAIN_STATE_UNAVAILABLE');
+    }
+}
+//# sourceMappingURL=lp-v3-evidence.js.map

package/dist/vendor/lp-v3/lp-v3-plan.d.ts

@@ -0,0 +1,22 @@
+import { type LpV3ChainEvidence, type LpV3Intent, type LpV3PreparedPlan } from './lp-v3-contract.js';
+declare const verifiedLpBrand: unique symbol;
+export interface VerifiedLpV3Plan {
+    readonly [verifiedLpBrand]: true;
+    readonly plan: LpV3PreparedPlan;
+    readonly evidence: LpV3ChainEvidence;
+    readonly verifiedAt: number;
+}
+/** Clock injection is a trusted host/test option, never an HTTP request field. */
+export interface LpV3VerifyOptions {
+    now?: () => number;
+}
+export declare function requireVerifiedLpV3Plan(value: VerifiedLpV3Plan): void;
+export declare function checkLpV3Context(intent: LpV3Intent, evidence: LpV3ChainEvidence, now: number): void;
+/** Preparation grants no wallet authority. Inputs are parsed and copied before use. */
+export declare function prepareLpV3Plan(input: unknown, chainEvidence: unknown, options?: LpV3VerifyOptions): LpV3PreparedPlan;
+/** independentIntent and freshEvidence MUST originate in the authenticated host.
+ * Deserialized client-supplied plans cannot confer either intent or chain authority.
+ * The host also enforces durable operation-ID admission, gas budgets and nonce claims.
+ */
+export declare function verifyLpV3Plan(input: unknown, independentIntent: unknown, freshEvidence: unknown, options?: LpV3VerifyOptions): VerifiedLpV3Plan;
+export {};

package/dist/vendor/lp-v3/lp-v3-plan.js

@@ -0,0 +1,135 @@
+import { encodeFunctionData } from 'viem';
+import { LP_V3_BASE, LP_V3_ERC20_ABI, LP_V3_NPM_ABI, canonicalJson, commitment, deepFreeze, lpV3ChainEvidenceSchema, lpV3IntentSchema, lpV3PreparedPlanSchema, } from './lp-v3-contract.js';
+import { sqrtPriceAtTick } from './v4-math.js';
+const verified = new WeakSet();
+export function requireVerifiedLpV3Plan(value) {
+    if (!value || !verified.has(value))
+        throw new Error('LP_UNVERIFIED_PLAN');
+}
+export function checkLpV3Context(intent, evidence, now) {
+    if (!Number.isSafeInteger(now) || now <= 0)
+        throw new Error('LP_INVALID_CLOCK');
+    if (intent.account !== intent.recipient || evidence.account !== intent.account)
+        throw new Error('LP_OWNER_RECIPIENT_MISMATCH');
+    if (evidence.observedAt > now || now - evidence.observedAt > 30 || evidence.blockTimestamp > evidence.observedAt || now - evidence.blockTimestamp > 60)
+        throw new Error('LP_STALE_CHAIN_EVIDENCE');
+    if (intent.deadline <= now || intent.deadline > now + 300)
+        throw new Error('LP_DEADLINE_OUT_OF_BOUNDS');
+    if (intent.pool !== evidence.pool || evidence.factoryPool !== intent.pool || intent.fee !== evidence.fee)
+        throw new Error('LP_POOL_MISMATCH');
+    const spacing = { 100: 1, 500: 10, 3000: 60, 10000: 200 }[intent.fee];
+    if (evidence.tickSpacing !== spacing || intent.tickLower % spacing || intent.tickUpper % spacing || intent.tickLower >= intent.tickUpper)
+        throw new Error('LP_INVALID_RANGE');
+    const sqrt = BigInt(evidence.sqrtPriceX96);
+    if (evidence.tick >= 887272 || sqrt < sqrtPriceAtTick(-887272) || sqrt >= sqrtPriceAtTick(887272) || sqrt < sqrtPriceAtTick(evidence.tick) || sqrt > sqrtPriceAtTick(evidence.tick + 1))
+        throw new Error('LP_INVALID_POOL_PRICE');
+    // Every supported operation starts with no standing ERC20 authority to the NPM.
+    // Recovery of a partially submitted sequence belongs to the durable execution journal.
+    if (evidence.allowances.some(v => v !== '0'))
+        throw new Error('LP_EXISTING_ALLOWANCE_REQUIRES_RECOVERY');
+    if (intent.action === 'mint') {
+        if (evidence.position !== null)
+            throw new Error('LP_UNEXPECTED_POSITION');
+    }
+    else {
+        const p = evidence.position;
+        if (intent.tokenId === '0' || !p || p.tokenId !== intent.tokenId || p.owner !== intent.account || p.token0 !== intent.token0 || p.token1 !== intent.token1 || p.fee !== intent.fee || p.tickLower !== intent.tickLower || p.tickUpper !== intent.tickUpper)
+            throw new Error('LP_NFT_IDENTITY_MISMATCH');
+    }
+    if (intent.action === 'mint' || intent.action === 'increase') {
+        if (intent.amountDesired.every(v => v === '0'))
+            throw new Error('LP_EMPTY_DEPOSIT');
+        for (const i of [0, 1]) {
+            const desired = BigInt(intent.amountDesired[i]), min = BigInt(intent.amountMin[i]);
+            if (desired > BigInt(evidence.balances[i]))
+                throw new Error('LP_INSUFFICIENT_BALANCE');
+            // Positive desired inputs require a positive onchain amount floor. A one-sided
+            // operation is expressed by setting BOTH desired and minimum of the other side to 0.
+            if (min > desired || (desired > 0n && min === 0n))
+                throw new Error('LP_INVALID_INPUT_FLOOR');
+        }
+    }
+    else if (intent.action === 'decrease') {
+        if (intent.liquidity === '0' || BigInt(intent.liquidity) > BigInt(evidence.position.liquidity) || intent.amountMin.every(v => v === '0'))
+            throw new Error('LP_INVALID_DECREASE');
+    }
+    else {
+        if (intent.amountMax.every(v => v === '0') || intent.amountMin.every(v => v === '0'))
+            throw new Error('LP_EMPTY_COLLECTION');
+        if (intent.amountMin.some((v, i) => BigInt(v) > BigInt(intent.amountMax[i])))
+            throw new Error('LP_INVALID_COLLECTION_FLOOR');
+    }
+}
+function deriveCalls(intent) {
+    const calls = [];
+    const add = (step, to, data, tokenIndex = null) => calls.push({ step, tokenIndex, chainId: 8453, from: intent.account, to, value: '0', data });
+    const addApproval = (i, amount, step) => add(step, i === 0 ? intent.token0 : intent.token1, encodeFunctionData({ abi: LP_V3_ERC20_ABI, functionName: 'approve', args: [LP_V3_BASE.manager, amount] }), i);
+    if (intent.action === 'mint' || intent.action === 'increase') {
+        for (const i of [0, 1])
+            if (intent.amountDesired[i] !== '0')
+                addApproval(i, BigInt(intent.amountDesired[i]), 'approve');
+        const amounts = { amount0Desired: BigInt(intent.amountDesired[0]), amount1Desired: BigInt(intent.amountDesired[1]), amount0Min: BigInt(intent.amountMin[0]), amount1Min: BigInt(intent.amountMin[1]), deadline: BigInt(intent.deadline) };
+        const data = intent.action === 'mint'
+            ? encodeFunctionData({ abi: LP_V3_NPM_ABI, functionName: 'mint', args: [{ ...amounts, token0: LP_V3_BASE.token0, token1: LP_V3_BASE.token1, fee: intent.fee, tickLower: intent.tickLower, tickUpper: intent.tickUpper, recipient: intent.recipient }] })
+            : encodeFunctionData({ abi: LP_V3_NPM_ABI, functionName: 'increaseLiquidity', args: [{ ...amounts, tokenId: BigInt(intent.tokenId) }] });
+        add('mutation', intent.manager, data);
+        // Always revoke the exact allowance after partial fills; never retain a remainder.
+        for (const i of [0, 1])
+            if (intent.amountDesired[i] !== '0')
+                addApproval(i, 0n, 'cleanup');
+    }
+    else if (intent.action === 'decrease') {
+        add('mutation', intent.manager, encodeFunctionData({ abi: LP_V3_NPM_ABI, functionName: 'decreaseLiquidity', args: [{ tokenId: BigInt(intent.tokenId), liquidity: BigInt(intent.liquidity), amount0Min: BigInt(intent.amountMin[0]), amount1Min: BigInt(intent.amountMin[1]), deadline: BigInt(intent.deadline) }] }));
+    }
+    else {
+        add('mutation', intent.manager, encodeFunctionData({ abi: LP_V3_NPM_ABI, functionName: 'collect', args: [{ tokenId: BigInt(intent.tokenId), recipient: intent.account, amount0Max: BigInt(intent.amountMax[0]), amount1Max: BigInt(intent.amountMax[1]) }] }));
+    }
+    return calls;
+}
+function signingSupport(intent) {
+    if (intent.action === 'increase')
+        return 'BLOCKED_ATOMIC_NFT_OWNER_GUARD';
+    if (intent.action === 'collect')
+        return 'BLOCKED_ATOMIC_COLLECTION_GUARD';
+    return 'HOST_GATES_REQUIRED';
+}
+/** Preparation grants no wallet authority. Inputs are parsed and copied before use. */
+export function prepareLpV3Plan(input, chainEvidence, options = {}) {
+    const intent = lpV3IntentSchema.parse(input), evidence = lpV3ChainEvidenceSchema.parse(chainEvidence);
+    const now = (options.now ?? (() => Math.floor(Date.now() / 1000)))();
+    checkLpV3Context(intent, evidence, now);
+    const body = { schemaVersion: 1, kind: 'lp-v3', intent, signingSupport: signingSupport(intent), intentCommitment: commitment(intent), calls: deriveCalls(intent), preparedBlock: { number: evidence.blockNumber, hash: evidence.blockHash } };
+    return deepFreeze({ ...body, planCommitment: commitment(body) });
+}
+/** independentIntent and freshEvidence MUST originate in the authenticated host.
+ * Deserialized client-supplied plans cannot confer either intent or chain authority.
+ * The host also enforces durable operation-ID admission, gas budgets and nonce claims.
+ */
+export function verifyLpV3Plan(input, independentIntent, freshEvidence, options = {}) {
+    const plan = lpV3PreparedPlanSchema.parse(input), intent = lpV3IntentSchema.parse(independentIntent), evidence = lpV3ChainEvidenceSchema.parse(freshEvidence);
+    const now = (options.now ?? (() => Math.floor(Date.now() / 1000)))();
+    checkLpV3Context(intent, evidence, now);
+    // An NFT operator can transfer an existing NFT after the read, and NPM increase
+    // is permissionless: it would still spend into that now-foreign NFT. Collection
+    // similarly cannot atomically enforce this contract's deadline/output floors.
+    // Neither action can acquire the verified runtime brand through this entry.
+    if (intent.action === 'increase')
+        throw new Error('LP_ATOMIC_NFT_OWNER_GUARD_REQUIRED');
+    if (intent.action === 'collect')
+        throw new Error('LP_ATOMIC_COLLECTION_GUARD_REQUIRED');
+    if (plan.signingSupport !== signingSupport(intent))
+        throw new Error('LP_SIGNING_SUPPORT_MISMATCH');
+    if (canonicalJson(plan.intent) !== canonicalJson(intent) || plan.intentCommitment !== commitment(intent))
+        throw new Error('LP_INDEPENDENT_INTENT_MISMATCH');
+    if (canonicalJson(plan.calls) !== canonicalJson(deriveCalls(intent)))
+        throw new Error('LP_CALL_SEQUENCE_MISMATCH');
+    const { planCommitment, ...body } = plan;
+    if (planCommitment !== commitment(body))
+        throw new Error('LP_PLAN_COMMITMENT_MISMATCH');
+    if (BigInt(plan.preparedBlock.number) > BigInt(evidence.blockNumber) || (plan.preparedBlock.number === evidence.blockNumber && plan.preparedBlock.hash !== evidence.blockHash))
+        throw new Error('LP_PREPARATION_BLOCK_MISMATCH');
+    const result = deepFreeze({ plan, evidence, verifiedAt: now });
+    verified.add(result);
+    return result;
+}
+//# sourceMappingURL=lp-v3-plan.js.map

package/dist/vendor/lp-v3/types.d.ts

@@ -0,0 +1,131 @@
+export type Hex = `0x${string}`;
+export type Pair<T> = [T, T];
+export interface PositionRef {
+    chainId: 4663;
+    positionManager: Hex;
+    tokenId: string;
+    expectedOwner?: Hex;
+}
+export interface PoolKey {
+    currency0: Hex;
+    currency1: Hex;
+    fee: number;
+    tickSpacing: number;
+    hooks: Hex;
+}
+export interface TokenInfo {
+    address: Hex;
+    symbol: string;
+    decimals: number;
+    paused: boolean | null;
+    oraclePaused: boolean | null;
+    multiplier: string | null;
+}
+export interface PositionSnapshot {
+    schemaVersion: 1;
+    snapshotId: string;
+    ref: PositionRef;
+    /** Absent on legacy snapshots means uniswap-v4. */
+    protocol?: 'uniswap-v3' | 'uniswap-v4';
+    observedAt: string;
+    block: {
+        number: string;
+        hash: Hex;
+        timestamp: string;
+        finality: 'latest' | 'safe' | 'finalized';
+    };
+    status: 'READY' | 'CLOSED' | 'UNSUPPORTED' | 'UNAVAILABLE';
+    owner: Hex | null;
+    pool: {
+        id: Hex;
+        address?: Hex;
+        key: PoolKey;
+        sqrtPriceX96: string;
+        tick: number;
+        lowerTick: number;
+        upperTick: number;
+        activeLiquidity: string;
+    } | null;
+    tokens: Pair<TokenInfo> | null;
+    liquidity: string | null;
+    principalRaw: Pair<string> | null;
+    feesOwedRaw: Pair<string> | null;
+    /** V3 stored collectable balances can contain withdrawn principal; never label these fees without history. */
+    tokensOwedRaw?: Pair<string> | null;
+    feeGrowthInsideX128: Pair<string> | null;
+    feeGrowthInsideLastX128: Pair<string> | null;
+    marksUsd: Pair<number | null>;
+    markSource: string;
+    warnings: string[];
+}
+export interface TrackingBaseline {
+    snapshot: PositionSnapshot;
+    establishedAt: string;
+    basis: 'since-tracking-start';
+}
+export interface WatchPolicy {
+    version: 1;
+    stopLossUsd: number | null;
+    takeProfitReviewUsd: number | null;
+    trailingDrawdownUsd: number | null;
+    rangeWarningFraction: number;
+    maxSnapshotAgeSeconds: number;
+    maxQuoteAgeSeconds: number;
+    maxRebalancePaybackHours: number;
+    minSwitchImprovementUsd: number;
+}
+export interface ExitQuote {
+    snapshotId: string;
+    quotedAt: string;
+    expiresAt: string;
+    settlementAsset: string;
+    netProceedsUsd: number;
+    completeExit: boolean;
+    source: 'simulated-sequential-exit';
+}
+export interface Opportunity {
+    id: string;
+    kind: 'rebalance' | 'rotate';
+    qualified: boolean;
+    sameChain: boolean;
+    costUsd: number | null;
+    conservativeIncrementalFeesUsdPerDay: number | null;
+    horizonHours: number;
+    exposureChange: string;
+    evidence: string[];
+}
+export interface Assessment {
+    schemaVersion: 1;
+    snapshotId: string;
+    policyVersion: 1;
+    assessedAt: string;
+    action: 'HOLD' | 'REVIEW' | 'REBALANCE_CANDIDATE' | 'EXIT_CANDIDATE' | 'ROTATE_CANDIDATE' | 'DATA_UNAVAILABLE';
+    reasons: string[];
+    metrics: {
+        principalValueUsd: number | null;
+        uncollectedFeesUsd: number | null;
+        positionValueUsd: number | null;
+        trackingMarkedPnlUsd: number | null;
+        trackingNetExitPnlUsd: number | null;
+        holdPrincipalValueUsd: number | null;
+        inventoryShortfallVsHoldUsd: number | null;
+        inventoryShortfallVsHoldPct: number | null;
+        ghoBenchmarkPnlUsd: number | null;
+        inRange: boolean | null;
+        boundaryDistanceFraction: number | null;
+    };
+    accountingCoverage: 'since-tracking-start' | 'snapshot-only' | 'gap';
+    requiresSignature: true;
+    alternatives: Array<{
+        id: string;
+        qualified: boolean;
+        reasons: string[];
+        paybackHours: number | null;
+        improvementUsd: number | null;
+    }>;
+}
+export declare const DEFAULT_POLICY: WatchPolicy;
+export interface PositionReader {
+    read(ref: PositionRef): Promise<PositionSnapshot>;
+    isCanonical?(snapshot: PositionSnapshot): Promise<boolean | null>;
+}

package/dist/vendor/lp-v3/types.js

@@ -0,0 +1,6 @@
+export const DEFAULT_POLICY = {
+    version: 1, stopLossUsd: 900, takeProfitReviewUsd: 450, trailingDrawdownUsd: null,
+    rangeWarningFraction: 0.2, maxSnapshotAgeSeconds: 120, maxQuoteAgeSeconds: 120,
+    maxRebalancePaybackHours: 48, minSwitchImprovementUsd: 10,
+};
+//# sourceMappingURL=types.js.map

package/dist/vendor/lp-v3/v4-math.d.ts

@@ -0,0 +1,18 @@
+import type { Hex, Pair, PoolKey } from './types.js';
+export declare const Q96: bigint;
+export declare const Q128: bigint;
+export declare const UINT256_MOD: bigint;
+export declare const MIN_TICK = -887272;
+export declare const MAX_TICK = 887272;
+export declare function sqrtPriceAtTick(tick: number): bigint;
+export declare function unpackPositionInfo(info: bigint): {
+    lowerTick: number;
+    upperTick: number;
+    poolIdPrefix: Hex;
+    hasSubscriber: boolean;
+};
+export declare function poolId(key: PoolKey): Hex;
+export declare function feesOwed(liquidity: bigint, current: Pair<bigint>, checkpoint: Pair<bigint>): Pair<bigint>;
+export declare function principalAmounts(liquidity: bigint, sqrtPriceX96: bigint, lowerTick: number, upperTick: number): Pair<bigint>;
+/** Human units of currency1 per one currency0. Display marks only, never raw accounting. */
+export declare function humanPriceRatio(sqrtPriceX96: bigint, decimals0: number, decimals1: number): number;