otto-intel-mcp 0.1.2 → 0.1.4

package/dist/vendor/lp-v3/lp-v3-collect-protocol-index.d.ts

@@ -0,0 +1,168 @@
+import { type LpV3GuardDeployment } from './lp-v3-atomic-contract.js';
+import { type LpV3CollectProtocolObservationOptions } from './lp-v3-collect-protocol-observation.js';
+import type { LpV3VerifyOptions } from './lp-v3-plan.js';
+/** NON-AUTHORIZING protocol component. The host supplies a reviewed immutable
+ * deployment policy and trusted read client. Default empty policy disables
+ * collection. This starts no signer, journal, RPC transport or background work.
+ * Account profile, atomic batch, provider enforcement, UserOp gas/finality and
+ * durable claims remain exclusively the host's separately verified gates.
+ */
+export declare function createLpV3CollectProtocolLibrary(options?: {
+    guardDeployments?: readonly LpV3GuardDeployment[];
+}): Readonly<{
+    policy: readonly {
+        id: "base-weth-usdc-collect-v1";
+        chainId: 8453;
+        address: string;
+        runtimeCodeHash: string;
+        configurationHash: `0x${string}`;
+        codeVersion: "OttoV3CollectGuard-v1";
+        deploymentBlock: string;
+        reviewReference: string;
+    }[];
+    collectProtocolEvidence: (intent: unknown, readOptions: LpV3CollectProtocolObservationOptions) => Promise<{
+        chainId: 8453;
+        fee: number;
+        blockNumber: string;
+        blockHash: string;
+        account: string;
+        factory: "0x33128a8fc17869897dce68ed026d694621f6fdfd";
+        blockTimestamp: number;
+        manager: "0x03a520b32c04bf3beef7beb72e919cf822ed34f1";
+        token0: "0x4200000000000000000000000000000000000006";
+        token1: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+        usdcImplementation: "0x2ce6311ddae708829bc0784c967b7d77d19fd779";
+        factoryCodeHash: `0x${string}`;
+        managerCodeHash: `0x${string}`;
+        token0CodeHash: `0x${string}`;
+        token1CodeHash: `0x${string}`;
+        usdcImplementationCodeHash: `0x${string}`;
+        pool: string;
+        balances: [string, string];
+        allowances: [string, string];
+        factoryPool: string;
+        tick: number;
+        observedAt: number;
+        managerFactory: "0x33128a8fc17869897dce68ed026d694621f6fdfd";
+        usdcPaused: false;
+        accountBlacklisted: false;
+        managerBlacklisted: false;
+        poolFactory: "0x33128a8fc17869897dce68ed026d694621f6fdfd";
+        tickSpacing: number;
+        sqrtPriceX96: string;
+        unlocked: true;
+        position: {
+            tokenId: string;
+            owner: string;
+            token0: string;
+            token1: string;
+            fee: number;
+            tickLower: number;
+            tickUpper: number;
+            liquidity: string;
+            tokensOwed: [string, string];
+            approved: string;
+        };
+        managerNativeBalance: string;
+        schemaVersion: 3;
+        accountCode: string;
+        accountCodeHash: string;
+        guard: {
+            address: string;
+            runtimeCodeHash: string;
+            configurationHash: string;
+            deploymentChainId: 8453;
+            ownerApprovalForAll: false;
+            guardBlacklisted: false;
+            poolBlacklisted: false;
+            tokenAllowances: ["0", "0"];
+            tokenBalances: [string, string];
+        };
+    }>;
+    prepare: (intent: unknown, observation: unknown, verifyOptions?: LpV3VerifyOptions) => {
+        intent: {
+            action: "collect";
+            tokenId: string;
+            amountMax: [string, string];
+            amountMin: [string, string];
+            protocol: "uniswap-v3";
+            chainId: 8453;
+            operationId: string;
+            account: string;
+            recipient: string;
+            manager: "0x03a520b32c04bf3beef7beb72e919cf822ed34f1";
+            factory: "0x33128a8fc17869897dce68ed026d694621f6fdfd";
+            pool: string;
+            token0: "0x4200000000000000000000000000000000000006";
+            token1: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+            fee: 10000 | 100 | 500 | 3000;
+            tickLower: number;
+            tickUpper: number;
+            deadline: number;
+            nftApprovalPolicy: "zero-before-and-after";
+            guardDeploymentId: "base-weth-usdc-collect-v1";
+            schemaVersion: 3;
+        };
+        intentCommitment: string;
+        policyCommitment: string;
+        guardDeployment: {
+            id: "base-weth-usdc-collect-v1";
+            chainId: 8453;
+            address: string;
+            runtimeCodeHash: string;
+            configurationHash: `0x${string}`;
+            codeVersion: "OttoV3CollectGuard-v1";
+            deploymentBlock: string;
+            reviewReference: string;
+        };
+        calls: [{
+            step: "mutation" | "erc20-approve" | "erc20-cleanup" | "nft-approve" | "nft-clear";
+            tokenIndex: 0 | 1 | null;
+            chainId: 8453;
+            from: string;
+            to: string;
+            value: "0";
+            data: string;
+        }, {
+            step: "mutation" | "erc20-approve" | "erc20-cleanup" | "nft-approve" | "nft-clear";
+            tokenIndex: 0 | 1 | null;
+            chainId: 8453;
+            from: string;
+            to: string;
+            value: "0";
+            data: string;
+        }];
+        preparedBlock: {
+            number: string;
+            hash: string;
+        };
+        preparedObservationCommitment: string;
+        planCommitment: string;
+        executionAuthorized: false;
+        transportVerified: false;
+        claimReleased: false;
+        retainClaim: true;
+        retrySafe: false;
+        schemaVersion: 3;
+        kind: "lp-v3-collect-protocol";
+    };
+    validatePrepared: (plan: unknown, independentIntent: unknown, observation: unknown, verifyOptions?: LpV3VerifyOptions) => {
+        planCommitment: string;
+        intentCommitment: string;
+        policyCommitment: string;
+        baselineCommitment: string;
+        checkedAt: number;
+        checkCommitment: string;
+        executionAuthorized: false;
+        transportVerified: false;
+        claimReleased: false;
+        retainClaim: true;
+        retrySafe: false;
+        schemaVersion: 3;
+        kind: "lp-v3-collect-protocol-check";
+    };
+    reconcileCollectProtocol: (input: unknown, verifyOptions?: LpV3VerifyOptions) => import("./lp-v3-collect-protocol-contract.js").LpV3CollectProtocolAccounting;
+}>;
+export { LP_V3_COLLECT_PROTOCOL_NO_AUTHORITY, lpV3CollectProtocolIntentSchema, lpV3CollectProtocolObservationSchema, lpV3CollectProtocolPlanSchema, lpV3CollectProtocolCheckSchema, lpV3CollectProtocolLogSchema, lpV3CollectProtocolBindingSchema, lpV3CollectProtocolEvidenceSchema, lpV3CollectProtocolReconcileInputSchema, } from './lp-v3-collect-protocol-contract.js';
+export type { LpV3CollectProtocolIntent, LpV3CollectProtocolObservation, LpV3CollectProtocolPlan, LpV3CollectProtocolCheck, LpV3CollectProtocolLog, LpV3CollectProtocolBinding, LpV3CollectProtocolEvidence, LpV3CollectProtocolReconcileInput, LpV3CollectProtocolAccounting, } from './lp-v3-collect-protocol-contract.js';
+export type { LpV3CollectProtocolObservationOptions, LpV3CollectProtocolReadClient } from './lp-v3-collect-protocol-observation.js';

package/dist/vendor/lp-v3/lp-v3-collect-protocol-index.js

@@ -0,0 +1,23 @@
+import { reviewedGuardPolicy } from './lp-v3-atomic-contract.js';
+import { prepareLpV3CollectProtocol, validateLpV3CollectProtocol } from './lp-v3-collect-protocol-plan.js';
+import { reconcileLpV3CollectProtocol } from './lp-v3-collect-protocol-reconcile.js';
+import { collectLpV3CollectProtocolEvidence } from './lp-v3-collect-protocol-observation.js';
+import { lpV3CollectProtocolIntentSchema } from './lp-v3-collect-protocol-contract.js';
+/** NON-AUTHORIZING protocol component. The host supplies a reviewed immutable
+ * deployment policy and trusted read client. Default empty policy disables
+ * collection. This starts no signer, journal, RPC transport or background work.
+ * Account profile, atomic batch, provider enforcement, UserOp gas/finality and
+ * durable claims remain exclusively the host's separately verified gates.
+ */
+export function createLpV3CollectProtocolLibrary(options = {}) {
+    const policy = reviewedGuardPolicy(options.guardDeployments);
+    return Object.freeze({
+        policy,
+        collectProtocolEvidence: (intent, readOptions) => collectLpV3CollectProtocolEvidence(lpV3CollectProtocolIntentSchema.parse(intent), policy, readOptions),
+        prepare: (intent, observation, verifyOptions) => prepareLpV3CollectProtocol(intent, observation, policy, verifyOptions),
+        validatePrepared: (plan, independentIntent, observation, verifyOptions) => validateLpV3CollectProtocol(plan, independentIntent, observation, policy, verifyOptions),
+        reconcileCollectProtocol: (input, verifyOptions) => reconcileLpV3CollectProtocol(input, policy, verifyOptions),
+    });
+}
+export { LP_V3_COLLECT_PROTOCOL_NO_AUTHORITY, lpV3CollectProtocolIntentSchema, lpV3CollectProtocolObservationSchema, lpV3CollectProtocolPlanSchema, lpV3CollectProtocolCheckSchema, lpV3CollectProtocolLogSchema, lpV3CollectProtocolBindingSchema, lpV3CollectProtocolEvidenceSchema, lpV3CollectProtocolReconcileInputSchema, } from './lp-v3-collect-protocol-contract.js';
+//# sourceMappingURL=lp-v3-collect-protocol-index.js.map

package/dist/vendor/lp-v3/lp-v3-collect-protocol-observation.d.ts

@@ -0,0 +1,32 @@
+import { type LpV3GuardDeployment } from './lp-v3-atomic-contract.js';
+import { type LpV3CollectProtocolIntent, type LpV3CollectProtocolObservation } from './lp-v3-collect-protocol-contract.js';
+type ReadRequest = {
+    method: 'eth_chainId' | 'eth_getBlockByNumber' | 'eth_getCode' | 'eth_getStorageAt' | 'eth_call' | 'eth_getBalance';
+    params?: readonly unknown[];
+};
+/** Trusted host dependency. No default HTTP provider or signer is constructed. */
+export interface LpV3CollectProtocolReadClient {
+    request(request: ReadRequest): Promise<unknown>;
+}
+export interface LpV3CollectProtocolObservationOptions {
+    client: LpV3CollectProtocolReadClient;
+    /** Trusted host wall clock in integer Unix seconds; never a block-time substitute. */
+    nowSeconds?: () => number;
+    /** Fresh mode only. Integer 1..60, default 60. */
+    maxBlockAgeSeconds?: number;
+    /** Wall-clock and independent monotonic deadline. Integer 1..30, default 30. */
+    maxReadDurationSeconds?: number;
+    /** Supplied by the host's canonical UserOp reader. This observer makes no finality claim. */
+    historicalAnchor?: {
+        number: string;
+        hash: string;
+        timestamp: number;
+    };
+}
+/** Collect-scoped protocol observation only. All state reads use one EIP-1898
+ * canonical hash, followed by a fresh number mapping and chain check. Historical
+ * mode never requests latest state, substitutes block time for the host clock, or
+ * claims finality. Actual nonempty account code is recorded, not profile-approved.
+ */
+export declare function collectLpV3CollectProtocolEvidence(input: LpV3CollectProtocolIntent, policy: readonly LpV3GuardDeployment[], options: LpV3CollectProtocolObservationOptions): Promise<LpV3CollectProtocolObservation>;
+export {};

package/dist/vendor/lp-v3/lp-v3-collect-protocol-observation.js

@@ -0,0 +1,228 @@
+import { decodeFunctionResult, encodeFunctionData, keccak256, parseAbi } from 'viem';
+import { z } from 'zod';
+import { LP_V3_BASE as B, deepFreeze, lpHash, lpUint } from './lp-v3-contract.js';
+import { lpV3AtomicPositionSchema, lpV3AtomicGuardEvidenceSchema, reviewedGuardPolicy, } from './lp-v3-atomic-contract.js';
+import { lpV3CollectProtocolIntentSchema, lpV3CollectProtocolObservationSchema, } from './lp-v3-collect-protocol-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)',
+    'function configurationHash() view returns (bytes32)', 'function deploymentChainId() view returns (uint256)',
+    'function isApprovedForAll(address owner,address operator) view returns (bool)',
+]);
+const READ_METHODS = new Set([
+    'eth_chainId', 'eth_getBlockByNumber', 'eth_getCode', 'eth_getStorageAt', 'eth_call', 'eth_getBalance',
+]);
+const historicalAnchorSchema = z.object({
+    number: lpUint(), hash: lpHash, timestamp: z.number().int().positive().safe(),
+}).strict();
+const FAILURE = 'LP_PROTOCOL_REQUIRED_CHAIN_STATE_UNAVAILABLE';
+function requireState(value) { if (!value)
+    throw new Error(FAILURE); }
+function hex(value) {
+    requireState(typeof value === 'string' && value.length <= 131_074 && /^0x(?:[0-9a-fA-F]{2})*$/.test(value));
+    return value.toLowerCase();
+}
+function address(value, zeroAllowed = false) {
+    requireState(typeof value === 'string' && /^0x[0-9a-fA-F]{40}$/.test(value)
+        && (zeroAllowed || !/^0x0{40}$/.test(value)));
+    return value.toLowerCase();
+}
+function quantity(value) {
+    requireState(typeof value === 'string' && /^0x(?:0|[1-9a-fA-F][0-9a-fA-F]{0,63})$/.test(value));
+    return BigInt(value);
+}
+function uint(value, bits = 256) {
+    requireState(typeof value === 'bigint' && value >= 0n && value < 1n << BigInt(bits));
+    return value;
+}
+function integer(value, minimum, maximum) {
+    requireState(typeof value === 'number' && Number.isSafeInteger(value) && value >= minimum && value <= maximum);
+    return value;
+}
+function tuple(value, length) {
+    requireState(Array.isArray(value) && value.length === length);
+    return value;
+}
+function block(value) {
+    requireState(value !== null && typeof value === 'object');
+    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));
+    return { number, hash, timestamp: Number(timestamp) };
+}
+/** Collect-scoped protocol observation only. All state reads use one EIP-1898
+ * canonical hash, followed by a fresh number mapping and chain check. Historical
+ * mode never requests latest state, substitutes block time for the host clock, or
+ * claims finality. Actual nonempty account code is recorded, not profile-approved.
+ */
+export async function collectLpV3CollectProtocolEvidence(input, policy, options) {
+    let stopped = false;
+    try {
+        // Copy caller intent and startup policy before the first asynchronous boundary.
+        const intent = deepFreeze(lpV3CollectProtocolIntentSchema.parse(input));
+        const guards = reviewedGuardPolicy(policy), deployment = guards.find(g => g.id === intent.guardDeploymentId);
+        requireState(deployment);
+        requireState(options?.client && typeof options.client.request === 'function');
+        const requestRpc = options.client.request.bind(options.client);
+        const now = options.nowSeconds ?? (() => Math.floor(Date.now() / 1000));
+        requireState(typeof now === 'function');
+        const maxAge = integer(options.maxBlockAgeSeconds ?? 60, 1, 60);
+        const maxDuration = integer(options.maxReadDurationSeconds ?? 30, 1, 30);
+        const historical = options.historicalAnchor === undefined ? undefined
+            : deepFreeze(historicalAnchorSchema.parse(options.historicalAnchor));
+        const startedMonotonic = performance.now();
+        let lastClock = 0;
+        const clock = () => {
+            const time = integer(now(), 1, Number.MAX_SAFE_INTEGER);
+            requireState(time >= lastClock);
+            lastClock = time;
+            return time;
+        };
+        const startedAt = clock();
+        const checkTime = () => {
+            requireState(!stopped);
+            const time = clock();
+            requireState(time - startedAt <= maxDuration && performance.now() - startedMonotonic <= maxDuration * 1000);
+            return time;
+        };
+        const rpc = async (request) => {
+            checkTime();
+            requireState(READ_METHODS.has(request.method));
+            let timer;
+            try {
+                const remaining = Math.max(1, maxDuration * 1000 - (performance.now() - startedMonotonic));
+                const result = await Promise.race([
+                    requestRpc(deepFreeze(request)),
+                    new Promise((_resolve, reject) => { timer = setTimeout(() => reject(new Error(FAILURE)), remaining); }),
+                ]);
+                checkTime();
+                return result;
+            }
+            catch {
+                stopped = true;
+                throw new Error(FAILURE);
+            }
+            finally {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+            }
+        };
+        const chain = async () => requireState(quantity(await rpc({ method: 'eth_chainId' })) === BigInt(B.chainId));
+        await chain();
+        const anchor = block(await rpc({
+            method: 'eth_getBlockByNumber',
+            params: [historical ? '0x' + BigInt(historical.number).toString(16) : 'latest', false],
+        }));
+        if (historical)
+            requireState(anchor.number.toString() === historical.number && anchor.hash === historical.hash && anchor.timestamp === historical.timestamp);
+        requireState(anchor.number >= BigInt(deployment.deploymentBlock));
+        const fresh = (time) => {
+            requireState(anchor.timestamp <= time);
+            if (!historical)
+                requireState(time - anchor.timestamp <= maxAge);
+        };
+        fresh(checkTime());
+        const reference = Object.freeze({ blockHash: anchor.hash, requireCanonical: true });
+        const read = async (target, functionName, args) => {
+            const data = encodeFunctionData({ abi: READ_ABI, functionName, args });
+            return decodeFunctionResult({ abi: READ_ABI, functionName,
+                data: hex(await rpc({ method: 'eth_call', params: [{ to: target, data }, reference] })) });
+        };
+        const getCode = async (target) => hex(await rpc({ method: 'eth_getCode', params: [target, reference] }));
+        const [factoryPoolRaw, factorySpacingRaw, managerFactoryRaw, managerWethRaw, accountCode, implementationStorage] = await Promise.all([
+            read(B.factory, 'getPool', [B.token0, B.token1, intent.fee]), read(B.factory, 'feeAmountTickSpacing', [intent.fee]),
+            read(B.manager, 'factory'), read(B.manager, 'WETH9'), getCode(intent.account),
+            rpc({ method: 'eth_getStorageAt', params: [B.token1, B.usdcImplementationSlot, reference] }),
+        ]);
+        const factoryPool = address(factoryPoolRaw), managerFactory = address(managerFactoryRaw);
+        requireState(factoryPool === intent.pool && managerFactory === B.factory && address(managerWethRaw) === B.token0);
+        requireState(accountCode !== '0x');
+        const storage = hex(implementationStorage);
+        requireState(/^0x0{24}[0-9a-f]{40}$/.test(storage));
+        const usdcImplementation = address('0x' + storage.slice(-40));
+        requireState(usdcImplementation === B.usdcImplementation);
+        const tickSpacing = integer(factorySpacingRaw, 1, 16_383);
+        requireState(intent.tickLower < intent.tickUpper && intent.tickLower % tickSpacing === 0 && intent.tickUpper % tickSpacing === 0);
+        const [poolFactoryRaw, token0Raw, token1Raw, feeRaw, spacingRaw, rawSlot, balancesRaw, allowancesRaw, paused, accountBlacklisted, managerBlacklisted, decimals, codes, positionRaw, managerNativeRaw] = await Promise.all([
+            read(factoryPool, 'factory'), read(factoryPool, 'token0'), read(factoryPool, 'token1'),
+            read(factoryPool, 'fee'), read(factoryPool, 'tickSpacing'), read(factoryPool, 'slot0'),
+            Promise.all([B.token0, B.token1].map(token => read(token, 'balanceOf', [intent.account]))),
+            Promise.all([B.token0, B.token1].map(token => read(token, 'allowance', [intent.account, B.manager]))),
+            read(B.token1, 'paused'), read(B.token1, 'isBlacklisted', [intent.account]), read(B.token1, 'isBlacklisted', [B.manager]),
+            Promise.all([B.token0, B.token1].map(token => read(token, 'decimals'))),
+            Promise.all([B.factory, B.manager, B.token0, B.token1, usdcImplementation, factoryPool].map(getCode)),
+            Promise.all([read(B.manager, 'ownerOf', [BigInt(intent.tokenId)]), read(B.manager, 'positions', [BigInt(intent.tokenId)])]),
+            rpc({ method: 'eth_getBalance', params: [B.manager, reference] }),
+        ]);
+        const poolFactory = address(poolFactoryRaw), token0 = address(token0Raw), token1 = address(token1Raw);
+        const fee = integer(feeRaw, 0, 999_999);
+        requireState(poolFactory === B.factory && token0 === B.token0 && token1 === B.token1 && fee === intent.fee && spacingRaw === tickSpacing);
+        requireState(paused === false && accountBlacklisted === false && managerBlacklisted === false);
+        requireState(decimals[0] === 18 && decimals[1] === 6);
+        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));
+        requireState(sqrt >= sqrtPriceAtTick(tick) && sqrt <= sqrtPriceAtTick(tick + 1));
+        const balances = balancesRaw.map(v => uint(v).toString()), allowances = allowancesRaw.map(v => uint(v).toString());
+        const data = tuple(positionRaw[1], 12);
+        const position = lpV3AtomicPositionSchema.parse({
+            tokenId: intent.tokenId, owner: address(positionRaw[0]), approved: address(data[1], true),
+            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 && position.token0 === token0 && position.token1 === token1
+            && position.fee === fee && position.tickLower === intent.tickLower && position.tickUpper === intent.tickUpper);
+        const managerNativeBalance = quantity(managerNativeRaw).toString();
+        requireState(codes.every(code => code !== '0x'));
+        const hashes = codes.slice(0, 5).map(code => keccak256(code));
+        const expectedHashes = [B.factoryCodeHash, B.managerCodeHash, B.token0CodeHash, B.token1CodeHash, B.usdcImplementationCodeHash];
+        requireState(hashes.every((hash, i) => hash === expectedHashes[i]));
+        const guardAddress = deployment.address;
+        const [guardCode, configurationHash, deploymentChainId, ownerApprovalForAll, tokenAllowances, tokenBalances, guardBlacklisted, poolBlacklisted] = await Promise.all([
+            getCode(guardAddress), read(guardAddress, 'configurationHash'), read(guardAddress, 'deploymentChainId'),
+            read(B.manager, 'isApprovedForAll', [intent.account, guardAddress]),
+            Promise.all([B.token0, B.token1].map(token => read(token, 'allowance', [guardAddress, B.manager]))),
+            Promise.all([B.token0, B.token1].map(token => read(token, 'balanceOf', [guardAddress]))),
+            read(B.token1, 'isBlacklisted', [guardAddress]), read(B.token1, 'isBlacklisted', [intent.pool]),
+        ]);
+        requireState(guardCode !== '0x' && keccak256(guardCode) === deployment.runtimeCodeHash
+            && configurationHash === deployment.configurationHash && deploymentChainId === 8453n);
+        const guard = lpV3AtomicGuardEvidenceSchema.parse({
+            address: guardAddress, runtimeCodeHash: keccak256(guardCode), configurationHash, deploymentChainId: 8453,
+            ownerApprovalForAll, tokenAllowances: tokenAllowances.map(v => uint(v).toString()),
+            tokenBalances: tokenBalances.map(v => uint(v).toString()), guardBlacklisted, poolBlacklisted,
+        });
+        const canonicalBlock = block(await rpc({ 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);
+        const observedAt = checkTime();
+        fresh(observedAt);
+        return deepFreeze(lpV3CollectProtocolObservationSchema.parse({
+            schemaVersion: 3, chainId: B.chainId, blockNumber: anchor.number.toString(), blockHash: anchor.hash,
+            blockTimestamp: anchor.timestamp, observedAt, account: intent.account, accountCode, accountCodeHash: keccak256(accountCode),
+            balances, allowances, manager: B.manager, managerFactory, factory: B.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, managerNativeBalance, guard,
+        }));
+    }
+    catch {
+        // Provider messages and decoding errors may contain credentials or raw payloads.
+        throw new Error(FAILURE);
+    }
+    finally {
+        stopped = true;
+    }
+}
+//# sourceMappingURL=lp-v3-collect-protocol-observation.js.map

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

@@ -0,0 +1,11 @@
+import { type LpV3GuardDeployment } from './lp-v3-atomic-contract.js';
+import type { LpV3VerifyOptions } from './lp-v3-plan.js';
+import { type LpV3CollectProtocolPlan, type LpV3CollectProtocolCheck } from './lp-v3-collect-protocol-contract.js';
+export declare class LpV3CollectProtocolError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare function requireProtocol(value: unknown, code: string): asserts value;
+export declare function protocolClock(options?: LpV3VerifyOptions): number;
+export declare function prepareLpV3CollectProtocol(input: unknown, rawObservation: unknown, policy: readonly LpV3GuardDeployment[], options?: LpV3VerifyOptions): LpV3CollectProtocolPlan;
+export declare function validateLpV3CollectProtocol(input: unknown, independentIntent: unknown, rawObservation: unknown, policy: readonly LpV3GuardDeployment[], options?: LpV3VerifyOptions): LpV3CollectProtocolCheck;

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

@@ -0,0 +1,91 @@
+import { encodeFunctionData } from 'viem';
+import { canonicalJson, commitment, deepFreeze, LP_V3_BASE as B } from './lp-v3-contract.js';
+import { LP_V3_ATOMIC_NPM_ABI, LP_V3_COLLECT_GUARD_ABI, reviewedGuardPolicy } from './lp-v3-atomic-contract.js';
+import { sqrtPriceAtTick } from './v4-math.js';
+import { LP_V3_COLLECT_PROTOCOL_NO_AUTHORITY as NO_AUTHORITY, lpV3CollectProtocolIntentSchema, lpV3CollectProtocolObservationSchema, lpV3CollectProtocolPlanSchema, lpV3CollectProtocolCheckSchema, } from './lp-v3-collect-protocol-contract.js';
+export class LpV3CollectProtocolError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'LpV3CollectProtocolError';
+    }
+}
+export function requireProtocol(value, code) {
+    if (!value)
+        throw new LpV3CollectProtocolError(code);
+}
+const ZERO = '0x0000000000000000000000000000000000000000';
+const same = (a, b) => canonicalJson(a) === canonicalJson(b);
+export function protocolClock(options = {}) {
+    const now = (options.now ?? (() => Math.floor(Date.now() / 1000)))();
+    requireProtocol(Number.isSafeInteger(now) && now > 0, 'LP_PROTOCOL_INVALID_CLOCK');
+    return now;
+}
+/** Collect-only protocol checks. This does not assert EOA or smart-account
+ * eligibility; the caller's reviewed UserOp profile owns that independent gate.
+ */
+function context(intent, e, policy, now) {
+    requireProtocol(e.account === intent.account && intent.recipient === intent.account, 'LP_PROTOCOL_OWNER_MISMATCH');
+    requireProtocol(e.observedAt <= now && now - e.observedAt <= 30 && e.blockTimestamp <= e.observedAt
+        && now - e.blockTimestamp <= 60, 'LP_PROTOCOL_STALE_OBSERVATION');
+    requireProtocol(intent.deadline > now && intent.deadline <= now + 300, 'LP_PROTOCOL_DEADLINE');
+    requireProtocol(intent.pool === e.pool && e.factoryPool === intent.pool && intent.fee === e.fee, 'LP_PROTOCOL_POOL_MISMATCH');
+    const spacing = { 100: 1, 500: 10, 3000: 60, 10000: 200 }[intent.fee];
+    requireProtocol(e.tickSpacing === spacing && intent.tickLower < intent.tickUpper
+        && intent.tickLower % spacing === 0 && intent.tickUpper % spacing === 0, 'LP_PROTOCOL_RANGE_MISMATCH');
+    const sqrt = BigInt(e.sqrtPriceX96);
+    requireProtocol(e.tick >= -887272 && e.tick < 887272 && sqrt >= sqrtPriceAtTick(-887272)
+        && sqrt < sqrtPriceAtTick(887272) && sqrt >= sqrtPriceAtTick(e.tick) && sqrt <= sqrtPriceAtTick(e.tick + 1), 'LP_PROTOCOL_POOL_PRICE');
+    const p = e.position;
+    requireProtocol(intent.tokenId !== '0' && 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, 'LP_PROTOCOL_NFT_MISMATCH');
+    requireProtocol(p.approved === ZERO && e.allowances.every(v => v === '0'), 'LP_PROTOCOL_EXISTING_APPROVAL');
+    requireProtocol(!intent.amountMax.every(v => v === '0') && !intent.amountMin.every(v => v === '0')
+        && intent.amountMin.every((v, i) => BigInt(v) <= BigInt(intent.amountMax[i])), 'LP_PROTOCOL_COLLECTION_BOUNDS');
+    const deployment = policy.find(d => d.id === intent.guardDeploymentId);
+    requireProtocol(deployment, 'LP_PROTOCOL_GUARD_UNAVAILABLE');
+    const g = e.guard;
+    requireProtocol(g.address === deployment.address && g.runtimeCodeHash === deployment.runtimeCodeHash
+        && g.configurationHash === deployment.configurationHash && BigInt(e.blockNumber) >= BigInt(deployment.deploymentBlock), 'LP_PROTOCOL_GUARD_MISMATCH');
+    return deployment;
+}
+function calls(intent, deployment) {
+    const base = { tokenIndex: null, chainId: 8453, from: intent.account, value: '0' };
+    return [
+        { ...base, step: 'nft-approve', to: B.manager, data: encodeFunctionData({ abi: LP_V3_ATOMIC_NPM_ABI,
+                functionName: 'approve', args: [deployment.address, BigInt(intent.tokenId)] }) },
+        { ...base, step: 'mutation', to: deployment.address, data: encodeFunctionData({ abi: LP_V3_COLLECT_GUARD_ABI,
+                functionName: 'collect', args: [{ owner: intent.account, pool: intent.pool, tokenId: BigInt(intent.tokenId),
+                        tickLower: intent.tickLower, tickUpper: intent.tickUpper,
+                        amount0Max: BigInt(intent.amountMax[0]), amount1Max: BigInt(intent.amountMax[1]),
+                        amount0Min: BigInt(intent.amountMin[0]), amount1Min: BigInt(intent.amountMin[1]), deadline: BigInt(intent.deadline) }] }) },
+    ];
+}
+export function prepareLpV3CollectProtocol(input, rawObservation, policy, options = {}) {
+    const intent = lpV3CollectProtocolIntentSchema.parse(input), observation = lpV3CollectProtocolObservationSchema.parse(rawObservation);
+    const guards = reviewedGuardPolicy(policy), deployment = context(intent, observation, guards, protocolClock(options));
+    const body = { schemaVersion: 3, kind: 'lp-v3-collect-protocol', ...NO_AUTHORITY,
+        intent, intentCommitment: commitment(intent), policyCommitment: commitment(guards), guardDeployment: deployment,
+        calls: calls(intent, deployment), preparedBlock: { number: observation.blockNumber, hash: observation.blockHash },
+        preparedObservationCommitment: commitment(observation) };
+    return deepFreeze(lpV3CollectProtocolPlanSchema.parse({ ...body, planCommitment: commitment(body) }));
+}
+export function validateLpV3CollectProtocol(input, independentIntent, rawObservation, policy, options = {}) {
+    const plan = lpV3CollectProtocolPlanSchema.parse(input), intent = lpV3CollectProtocolIntentSchema.parse(independentIntent);
+    const observation = lpV3CollectProtocolObservationSchema.parse(rawObservation), checkedAt = protocolClock(options);
+    const guards = reviewedGuardPolicy(policy), deployment = context(intent, observation, guards, checkedAt);
+    requireProtocol(same(plan.intent, intent) && plan.intentCommitment === commitment(intent), 'LP_PROTOCOL_INTENT_MISMATCH');
+    requireProtocol(plan.policyCommitment === commitment(guards) && same(plan.guardDeployment, deployment), 'LP_PROTOCOL_POLICY_MISMATCH');
+    requireProtocol(same(plan.calls, calls(intent, deployment)), 'LP_PROTOCOL_CALL_MISMATCH');
+    const { planCommitment, ...body } = plan;
+    requireProtocol(planCommitment === commitment(body), 'LP_PROTOCOL_PLAN_COMMITMENT');
+    requireProtocol(BigInt(plan.preparedBlock.number) <= BigInt(observation.blockNumber)
+        && (plan.preparedBlock.number !== observation.blockNumber || plan.preparedBlock.hash === observation.blockHash), 'LP_PROTOCOL_PREPARATION_BLOCK');
+    const check = { schemaVersion: 3, kind: 'lp-v3-collect-protocol-check', ...NO_AUTHORITY,
+        planCommitment, intentCommitment: plan.intentCommitment, policyCommitment: plan.policyCommitment,
+        baselineCommitment: commitment(observation), checkedAt };
+    return deepFreeze(lpV3CollectProtocolCheckSchema.parse({ ...check, checkCommitment: commitment(check) }));
+}
+//# sourceMappingURL=lp-v3-collect-protocol-plan.js.map

package/dist/vendor/lp-v3/lp-v3-collect-protocol-reconcile.d.ts

@@ -0,0 +1,9 @@
+import { type LpV3GuardDeployment } from './lp-v3-atomic-contract.js';
+import type { LpV3VerifyOptions } from './lp-v3-plan.js';
+import { type LpV3CollectProtocolAccounting } from './lp-v3-collect-protocol-contract.js';
+/** Protocol accounting only. Raw inputs, including UserOp status and the window,
+ * cannot prove transport, finality, account authority or release a durable claim.
+ * The host authenticates the entire receipt and derives the COMPLETE operation
+ * slice before calling this helper; both supplied boundary indices are exclusive.
+ */
+export declare function reconcileLpV3CollectProtocol(input: unknown, policy: readonly LpV3GuardDeployment[], options?: LpV3VerifyOptions): LpV3CollectProtocolAccounting;