otto-intel-mcp 0.1.2 → 0.1.4

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

@@ -0,0 +1,124 @@
+import { decodeEventLog, parseAbi } from 'viem';
+import { canonicalJson, commitment, deepFreeze, LP_V3_BASE as B } from './lp-v3-contract.js';
+import { LP_V3_COLLECT_GUARD_ABI } from './lp-v3-atomic-contract.js';
+import { LP_V3_COLLECT_PROTOCOL_NO_AUTHORITY as NO_AUTHORITY, lpV3CollectProtocolReconcileInputSchema, } from './lp-v3-collect-protocol-contract.js';
+import { protocolClock, requireProtocol as need, validateLpV3CollectProtocol } from './lp-v3-collect-protocol-plan.js';
+const ZERO = '0x0000000000000000000000000000000000000000';
+const NPM = parseAbi([
+    'event Approval(address indexed owner,address indexed approved,uint256 indexed tokenId)',
+    'event Transfer(address indexed from,address indexed to,uint256 indexed tokenId)',
+    'event Collect(uint256 indexed tokenId,address recipient,uint256 amount0,uint256 amount1)',
+]);
+const TOKEN = parseAbi([
+    'event Approval(address indexed owner,address indexed spender,uint256 value)',
+    'event Transfer(address indexed from,address indexed to,uint256 value)',
+]);
+const same = (a, b) => canonicalJson(a) === canonicalJson(b);
+const decodeNpm = (l) => decodeEventLog({ abi: NPM, topics: l.topics, data: l.data, strict: true });
+const decodeToken = (l) => decodeEventLog({ abi: TOKEN, topics: l.topics, data: l.data, strict: true });
+/** 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 function reconcileLpV3CollectProtocol(input, policy, options = {}) {
+    try {
+        const { plan, independentIntent: intent, baseline: before, check, evidence } = lpV3CollectProtocolReconcileInputSchema.parse(input);
+        const now = protocolClock(options), { binding: b, post, logs } = evidence;
+        need(same(check, validateLpV3CollectProtocol(plan, intent, before, policy, { now: () => check.checkedAt })), 'LP_PROTOCOL_CHECK_MISMATCH');
+        need(evidence.planCommitment === plan.planCommitment && b.account === intent.account, 'LP_PROTOCOL_OPERATION_BINDING');
+        // Chain causality uses the canonical baseline, not the host check wall clock:
+        // a valid next block can retain sequencer timestamp lag within the read budget.
+        need(post.observedAt <= now && now - post.observedAt <= 30 && post.blockTimestamp <= post.observedAt
+            && b.blockTimestamp > before.blockTimestamp && b.blockTimestamp <= now
+            && BigInt(b.blockNumber) > BigInt(before.blockNumber), 'LP_PROTOCOL_SETTLEMENT_TIME');
+        // A reverted expired call is reconcilable; only successful collection must
+        // satisfy the original in-contract deadline.
+        need(evidence.status === 'reverted' || b.blockTimestamp <= intent.deadline, 'LP_PROTOCOL_LATE_COLLECTION');
+        need(post.blockNumber === b.blockNumber && post.blockHash === b.blockHash && post.blockTimestamp === b.blockTimestamp, 'LP_PROTOCOL_POST_BLOCK');
+        need(b.windowStartLogIndex < b.userOpEventLogIndex && logs.length === b.userOpEventLogIndex - b.windowStartLogIndex - 1, 'LP_PROTOCOL_INCOMPLETE_OPERATION_WINDOW');
+        for (const [i, l] of logs.entries())
+            need(l.logIndex === b.windowStartLogIndex + i + 1
+                && l.transactionHash === b.transactionHash && l.transactionIndex === b.transactionIndex
+                && l.blockNumber === b.blockNumber && l.blockHash === b.blockHash, 'LP_PROTOCOL_LOG_BINDING_OR_ORDER');
+        const p = post.position;
+        need(post.account === intent.account && post.accountCode === before.accountCode && post.accountCodeHash === before.accountCodeHash
+            && post.pool === intent.pool && post.factoryPool === intent.pool && post.fee === intent.fee && post.tickSpacing === before.tickSpacing
+            && p.tokenId === intent.tokenId && p.owner === intent.account && p.approved === ZERO
+            && p.token0 === intent.token0 && p.token1 === intent.token1 && p.fee === intent.fee
+            && p.tickLower === intent.tickLower && p.tickUpper === intent.tickUpper && p.liquidity === before.position.liquidity
+            && post.allowances.every(v => v === '0'), 'LP_PROTOCOL_POST_IDENTITY_OR_APPROVAL');
+        need(same(post.guard, before.guard), 'LP_PROTOCOL_GUARD_POST_STATE');
+        const npmLogs = logs.filter(l => l.address === B.manager), guards = logs.filter(l => l.address === plan.guardDeployment.address);
+        const received = [0n, 0n];
+        if (evidence.status === 'reverted') {
+            need(npmLogs.length === 0 && guards.length === 0 && same(p, before.position), 'LP_PROTOCOL_REVERT_ROLLBACK_UNPROVEN');
+        }
+        else {
+            const npm = npmLogs.map(decodeNpm);
+            need(same(npm.map(e => e.eventName), ['Approval', 'Collect', 'Approval', 'Transfer']) && guards.length === 1, 'LP_PROTOCOL_COLLECTION_EVENT_SEQUENCE');
+            for (const [i, e] of npm.entries()) {
+                need(e.args.tokenId.toString() === intent.tokenId, 'LP_PROTOCOL_EVENT_NFT');
+                if (e.eventName === 'Approval')
+                    need(e.args.owner.toLowerCase() === intent.account
+                        && e.args.approved.toLowerCase() === (i === 0 ? plan.guardDeployment.address : ZERO), 'LP_PROTOCOL_APPROVAL_SEQUENCE');
+                if (e.eventName === 'Transfer')
+                    need(e.args.from.toLowerCase() === intent.account && e.args.to.toLowerCase() === intent.account, 'LP_PROTOCOL_OWNER_SELF_TRANSFER');
+            }
+            const collect = npm[1], guardLog = guards[0];
+            need(collect.eventName === 'Collect' && collect.args.recipient.toLowerCase() === intent.account
+                && guardLog.logIndex > npmLogs[3].logIndex, 'LP_PROTOCOL_COLLECTION_RECIPIENT');
+            const g = decodeEventLog({ abi: LP_V3_COLLECT_GUARD_ABI, topics: guardLog.topics, data: guardLog.data, strict: true });
+            need(g.eventName === 'Collected' && g.args.owner.toLowerCase() === intent.account && g.args.pool.toLowerCase() === intent.pool
+                && g.args.tokenId.toString() === intent.tokenId, 'LP_PROTOCOL_GUARD_EVENT_BINDING');
+            received[0] = g.args.amount0;
+            received[1] = g.args.amount1;
+            const owed = [collect.args.amount0, collect.args.amount1];
+            for (const i of [0, 1]) {
+                need(received[i] >= BigInt(intent.amountMin[i]) && received[i] <= BigInt(intent.amountMax[i])
+                    && owed[i] >= received[i] && owed[i] <= BigInt(intent.amountMax[i]), 'LP_PROTOCOL_COLLECTION_AMOUNTS');
+                const remaining = BigInt(before.position.tokensOwed[i]) - owed[i];
+                need(before.position.liquidity === '0' ? remaining >= 0n && BigInt(p.tokensOwed[i]) === remaining
+                    : BigInt(p.tokensOwed[i]) >= (remaining > 0n ? remaining : 0n), 'LP_PROTOCOL_OWED_BALANCE');
+            }
+        }
+        const transfers = [0n, 0n];
+        for (const l of logs) {
+            const i = l.address === B.token0 ? 0 : l.address === B.token1 ? 1 : null;
+            if (i === null)
+                continue;
+            const e = decodeToken(l);
+            // Unrelated token movements can occur in this whole operation window.
+            // Any owner/guard approval or extra owner/guard flow is ambiguous and held.
+            if (e.eventName === 'Approval') {
+                need(![intent.account, plan.guardDeployment.address].includes(e.args.owner.toLowerCase()), 'LP_PROTOCOL_EXTRA_TOKEN_APPROVAL');
+                continue;
+            }
+            const from = e.args.from.toLowerCase(), to = e.args.to.toLowerCase();
+            need(from !== plan.guardDeployment.address && to !== plan.guardDeployment.address, 'LP_PROTOCOL_GUARD_TOKEN_FLOW');
+            if (from !== intent.account && to !== intent.account)
+                continue;
+            need(evidence.status === 'success' && from === intent.pool && to === intent.account
+                && l.logIndex > npmLogs[0].logIndex && l.logIndex < npmLogs[1].logIndex, 'LP_PROTOCOL_EXTRA_OWNER_TOKEN_FLOW');
+            transfers[i] += e.args.value;
+        }
+        need(same(transfers.map(String), received.map(String)), 'LP_PROTOCOL_TOKEN_RECEIPTS_MISMATCH');
+        // Block-end owner balances may include another UserOp, incoming transfers or
+        // token gas charges. They are observations, not an LP proceeds delta proof.
+        const body = { ...NO_AUTHORITY, status: 'PROTOCOL_ACCOUNTED',
+            outcome: evidence.status === 'success' ? 'collected' : 'reverted',
+            planCommitment: plan.planCommitment, baselineCommitment: check.baselineCommitment,
+            effectsCommitment: commitment({ binding: b, status: evidence.status, logs }), postObservationCommitment: commitment(post),
+            userOpHash: b.userOpHash, transactionHash: b.transactionHash, blockHash: b.blockHash, blockNumber: b.blockNumber,
+            owner: intent.account, tokenId: intent.tokenId, collectedRaw: received.map(String), liquidityDelta: '0',
+            nftTokenApprovalCleared: true, erc20AllowancesCleared: true,
+            accountingBasis: 'guard-call-and-operation-logs', ownerBalancesAtBlock: post.balances,
+            profitClassification: 'UNKNOWN', distributableProfitRaw: null };
+        return deepFreeze({ ...body, accountingCommitment: commitment(body) });
+    }
+    catch (error) {
+        const reason = error instanceof Error && /^LP_PROTOCOL_[A-Z_]+$/.test(error.message) ? error.message : 'LP_PROTOCOL_MALFORMED_OR_UNSUPPORTED_EVIDENCE';
+        return deepFreeze({ ...NO_AUTHORITY, status: 'HELD', settlement: 'UNKNOWN', reason });
+    }
+}
+//# sourceMappingURL=lp-v3-collect-protocol-reconcile.js.map

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

@@ -0,0 +1,538 @@
+import { z } from 'zod';
+export declare const LP_V3_BASE: Readonly<{
+    readonly chainId: 8453;
+    readonly factory: "0x33128a8fc17869897dce68ed026d694621f6fdfd";
+    readonly manager: "0x03a520b32c04bf3beef7beb72e919cf822ed34f1";
+    readonly token0: "0x4200000000000000000000000000000000000006";
+    readonly token1: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+    readonly factoryCodeHash: `0x${string}`;
+    readonly managerCodeHash: `0x${string}`;
+    readonly token0CodeHash: `0x${string}`;
+    readonly token1CodeHash: `0x${string}`;
+    readonly usdcImplementationSlot: `0x${string}`;
+    readonly usdcImplementation: "0x2ce6311ddae708829bc0784c967b7d77d19fd779";
+    readonly usdcImplementationCodeHash: `0x${string}`;
+}>;
+export declare const lpAddress: z.ZodString;
+export declare const lpHash: z.ZodString;
+export declare const lpUint: (bits?: number) => z.ZodString;
+export declare const lpV3IntentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"mint">;
+    amountDesired: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    amountMin: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    schemaVersion: z.ZodLiteral<1>;
+    protocol: z.ZodLiteral<"uniswap-v3">;
+    chainId: z.ZodLiteral<8453>;
+    operationId: z.ZodString;
+    account: z.ZodString;
+    recipient: z.ZodString;
+    manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+    factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+    pool: z.ZodString;
+    token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+    token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+    fee: z.ZodUnion<readonly [z.ZodLiteral<100>, z.ZodLiteral<500>, z.ZodLiteral<3000>, z.ZodLiteral<10000>]>;
+    tickLower: z.ZodNumber;
+    tickUpper: z.ZodNumber;
+    deadline: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"increase">;
+    tokenId: z.ZodString;
+    amountDesired: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    amountMin: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    schemaVersion: z.ZodLiteral<1>;
+    protocol: z.ZodLiteral<"uniswap-v3">;
+    chainId: z.ZodLiteral<8453>;
+    operationId: z.ZodString;
+    account: z.ZodString;
+    recipient: z.ZodString;
+    manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+    factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+    pool: z.ZodString;
+    token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+    token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+    fee: z.ZodUnion<readonly [z.ZodLiteral<100>, z.ZodLiteral<500>, z.ZodLiteral<3000>, z.ZodLiteral<10000>]>;
+    tickLower: z.ZodNumber;
+    tickUpper: z.ZodNumber;
+    deadline: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"decrease">;
+    tokenId: z.ZodString;
+    liquidity: z.ZodString;
+    amountMin: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    schemaVersion: z.ZodLiteral<1>;
+    protocol: z.ZodLiteral<"uniswap-v3">;
+    chainId: z.ZodLiteral<8453>;
+    operationId: z.ZodString;
+    account: z.ZodString;
+    recipient: z.ZodString;
+    manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+    factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+    pool: z.ZodString;
+    token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+    token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+    fee: z.ZodUnion<readonly [z.ZodLiteral<100>, z.ZodLiteral<500>, z.ZodLiteral<3000>, z.ZodLiteral<10000>]>;
+    tickLower: z.ZodNumber;
+    tickUpper: z.ZodNumber;
+    deadline: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"collect">;
+    tokenId: z.ZodString;
+    amountMax: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    amountMin: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    schemaVersion: z.ZodLiteral<1>;
+    protocol: z.ZodLiteral<"uniswap-v3">;
+    chainId: z.ZodLiteral<8453>;
+    operationId: z.ZodString;
+    account: z.ZodString;
+    recipient: z.ZodString;
+    manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+    factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+    pool: z.ZodString;
+    token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+    token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+    fee: z.ZodUnion<readonly [z.ZodLiteral<100>, z.ZodLiteral<500>, z.ZodLiteral<3000>, z.ZodLiteral<10000>]>;
+    tickLower: z.ZodNumber;
+    tickUpper: z.ZodNumber;
+    deadline: z.ZodNumber;
+}, z.core.$strict>], "action">;
+export type LpV3Intent = z.infer<typeof lpV3IntentSchema>;
+export declare const lpV3PositionSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+    owner: z.ZodString;
+    token0: z.ZodString;
+    token1: z.ZodString;
+    fee: z.ZodNumber;
+    tickLower: z.ZodNumber;
+    tickUpper: z.ZodNumber;
+    liquidity: z.ZodString;
+    tokensOwed: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>;
+export type LpV3Position = z.infer<typeof lpV3PositionSchema>;
+export declare const lpV3ChainEvidenceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    chainId: z.ZodLiteral<8453>;
+    blockNumber: z.ZodString;
+    blockHash: z.ZodString;
+    blockTimestamp: z.ZodNumber;
+    observedAt: z.ZodNumber;
+    canonical: z.ZodLiteral<true>;
+    account: z.ZodString;
+    accountCode: z.ZodLiteral<"0x">;
+    balances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    allowances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+    managerFactory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+    factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+    factoryPool: z.ZodString;
+    factoryCodeHash: z.ZodLiteral<`0x${string}`>;
+    managerCodeHash: z.ZodLiteral<`0x${string}`>;
+    token0CodeHash: z.ZodLiteral<`0x${string}`>;
+    token1CodeHash: z.ZodLiteral<`0x${string}`>;
+    usdcImplementation: z.ZodLiteral<"0x2ce6311ddae708829bc0784c967b7d77d19fd779">;
+    usdcImplementationCodeHash: z.ZodLiteral<`0x${string}`>;
+    usdcPaused: z.ZodLiteral<false>;
+    accountBlacklisted: z.ZodLiteral<false>;
+    managerBlacklisted: z.ZodLiteral<false>;
+    pool: z.ZodString;
+    poolFactory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+    token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+    token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+    fee: z.ZodNumber;
+    tickSpacing: z.ZodNumber;
+    tick: z.ZodNumber;
+    sqrtPriceX96: z.ZodString;
+    unlocked: z.ZodLiteral<true>;
+    position: z.ZodNullable<z.ZodObject<{
+        tokenId: z.ZodString;
+        owner: z.ZodString;
+        token0: z.ZodString;
+        token1: z.ZodString;
+        fee: z.ZodNumber;
+        tickLower: z.ZodNumber;
+        tickUpper: z.ZodNumber;
+        liquidity: z.ZodString;
+        tokensOwed: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LpV3ChainEvidence = z.infer<typeof lpV3ChainEvidenceSchema>;
+export declare const lpV3CallSchema: z.ZodObject<{
+    step: z.ZodEnum<{
+        approve: "approve";
+        mutation: "mutation";
+        cleanup: "cleanup";
+    }>;
+    tokenIndex: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    chainId: z.ZodLiteral<8453>;
+    from: z.ZodString;
+    to: z.ZodString;
+    value: z.ZodLiteral<"0">;
+    data: z.ZodString;
+}, z.core.$strict>;
+export type LpV3Call = z.infer<typeof lpV3CallSchema>;
+export declare const lpV3SigningSupportSchema: z.ZodEnum<{
+    HOST_GATES_REQUIRED: "HOST_GATES_REQUIRED";
+    BLOCKED_ATOMIC_NFT_OWNER_GUARD: "BLOCKED_ATOMIC_NFT_OWNER_GUARD";
+    BLOCKED_ATOMIC_COLLECTION_GUARD: "BLOCKED_ATOMIC_COLLECTION_GUARD";
+}>;
+export declare const lpV3PreparedPlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"lp-v3">;
+    intent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"mint">;
+        amountDesired: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        amountMin: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        schemaVersion: z.ZodLiteral<1>;
+        protocol: z.ZodLiteral<"uniswap-v3">;
+        chainId: z.ZodLiteral<8453>;
+        operationId: z.ZodString;
+        account: z.ZodString;
+        recipient: z.ZodString;
+        manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+        factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        pool: z.ZodString;
+        token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+        token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+        fee: z.ZodUnion<readonly [z.ZodLiteral<100>, z.ZodLiteral<500>, z.ZodLiteral<3000>, z.ZodLiteral<10000>]>;
+        tickLower: z.ZodNumber;
+        tickUpper: z.ZodNumber;
+        deadline: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"increase">;
+        tokenId: z.ZodString;
+        amountDesired: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        amountMin: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        schemaVersion: z.ZodLiteral<1>;
+        protocol: z.ZodLiteral<"uniswap-v3">;
+        chainId: z.ZodLiteral<8453>;
+        operationId: z.ZodString;
+        account: z.ZodString;
+        recipient: z.ZodString;
+        manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+        factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        pool: z.ZodString;
+        token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+        token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+        fee: z.ZodUnion<readonly [z.ZodLiteral<100>, z.ZodLiteral<500>, z.ZodLiteral<3000>, z.ZodLiteral<10000>]>;
+        tickLower: z.ZodNumber;
+        tickUpper: z.ZodNumber;
+        deadline: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"decrease">;
+        tokenId: z.ZodString;
+        liquidity: z.ZodString;
+        amountMin: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        schemaVersion: z.ZodLiteral<1>;
+        protocol: z.ZodLiteral<"uniswap-v3">;
+        chainId: z.ZodLiteral<8453>;
+        operationId: z.ZodString;
+        account: z.ZodString;
+        recipient: z.ZodString;
+        manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+        factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        pool: z.ZodString;
+        token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+        token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+        fee: z.ZodUnion<readonly [z.ZodLiteral<100>, z.ZodLiteral<500>, z.ZodLiteral<3000>, z.ZodLiteral<10000>]>;
+        tickLower: z.ZodNumber;
+        tickUpper: z.ZodNumber;
+        deadline: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"collect">;
+        tokenId: z.ZodString;
+        amountMax: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        amountMin: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        schemaVersion: z.ZodLiteral<1>;
+        protocol: z.ZodLiteral<"uniswap-v3">;
+        chainId: z.ZodLiteral<8453>;
+        operationId: z.ZodString;
+        account: z.ZodString;
+        recipient: z.ZodString;
+        manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+        factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        pool: z.ZodString;
+        token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+        token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+        fee: z.ZodUnion<readonly [z.ZodLiteral<100>, z.ZodLiteral<500>, z.ZodLiteral<3000>, z.ZodLiteral<10000>]>;
+        tickLower: z.ZodNumber;
+        tickUpper: z.ZodNumber;
+        deadline: z.ZodNumber;
+    }, z.core.$strict>], "action">;
+    signingSupport: z.ZodEnum<{
+        HOST_GATES_REQUIRED: "HOST_GATES_REQUIRED";
+        BLOCKED_ATOMIC_NFT_OWNER_GUARD: "BLOCKED_ATOMIC_NFT_OWNER_GUARD";
+        BLOCKED_ATOMIC_COLLECTION_GUARD: "BLOCKED_ATOMIC_COLLECTION_GUARD";
+    }>;
+    intentCommitment: z.ZodString;
+    calls: z.ZodArray<z.ZodObject<{
+        step: z.ZodEnum<{
+            approve: "approve";
+            mutation: "mutation";
+            cleanup: "cleanup";
+        }>;
+        tokenIndex: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        chainId: z.ZodLiteral<8453>;
+        from: z.ZodString;
+        to: z.ZodString;
+        value: z.ZodLiteral<"0">;
+        data: z.ZodString;
+    }, z.core.$strict>>;
+    preparedBlock: z.ZodObject<{
+        number: z.ZodString;
+        hash: z.ZodString;
+    }, z.core.$strict>;
+    planCommitment: z.ZodString;
+}, z.core.$strict>;
+export type LpV3PreparedPlan = z.infer<typeof lpV3PreparedPlanSchema>;
+export declare const LP_V3_NPM_ABI: readonly [{
+    readonly name: "mint";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "token0";
+        }, {
+            readonly type: "address";
+            readonly name: "token1";
+        }, {
+            readonly type: "uint24";
+            readonly name: "fee";
+        }, {
+            readonly type: "int24";
+            readonly name: "tickLower";
+        }, {
+            readonly type: "int24";
+            readonly name: "tickUpper";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount0Desired";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount1Desired";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount0Min";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount1Min";
+        }, {
+            readonly type: "address";
+            readonly name: "recipient";
+        }, {
+            readonly type: "uint256";
+            readonly name: "deadline";
+        }];
+        readonly name: "params";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "tokenId";
+    }, {
+        readonly type: "uint128";
+        readonly name: "liquidity";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount0";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount1";
+    }];
+}, {
+    readonly name: "increaseLiquidity";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint256";
+            readonly name: "tokenId";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount0Desired";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount1Desired";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount0Min";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount1Min";
+        }, {
+            readonly type: "uint256";
+            readonly name: "deadline";
+        }];
+        readonly name: "params";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint128";
+        readonly name: "liquidity";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount0";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount1";
+    }];
+}, {
+    readonly name: "decreaseLiquidity";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint256";
+            readonly name: "tokenId";
+        }, {
+            readonly type: "uint128";
+            readonly name: "liquidity";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount0Min";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount1Min";
+        }, {
+            readonly type: "uint256";
+            readonly name: "deadline";
+        }];
+        readonly name: "params";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amount0";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount1";
+    }];
+}, {
+    readonly name: "collect";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint256";
+            readonly name: "tokenId";
+        }, {
+            readonly type: "address";
+            readonly name: "recipient";
+        }, {
+            readonly type: "uint128";
+            readonly name: "amount0Max";
+        }, {
+            readonly type: "uint128";
+            readonly name: "amount1Max";
+        }];
+        readonly name: "params";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amount0";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount1";
+    }];
+}, {
+    readonly name: "IncreaseLiquidity";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "tokenId";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint128";
+        readonly name: "liquidity";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount0";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount1";
+    }];
+}, {
+    readonly name: "DecreaseLiquidity";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "tokenId";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint128";
+        readonly name: "liquidity";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount0";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount1";
+    }];
+}, {
+    readonly name: "Collect";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "tokenId";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "recipient";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount0";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount1";
+    }];
+}, {
+    readonly name: "Transfer";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "from";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "to";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "tokenId";
+        readonly indexed: true;
+    }];
+}];
+export declare const LP_V3_ERC20_ABI: readonly [{
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "Transfer";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "from";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "to";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "value";
+    }];
+}];
+export declare function canonicalJson(value: unknown): string;
+export declare const commitment: (value: unknown) => `0x${string}`;
+export declare function deepFreeze<T>(value: T): T;