otto-intel-mcp 0.1.3 → 0.1.4

package/dist/lp-userop.d.ts

@@ -0,0 +1,643 @@
+/** Read-only LP preparation and atomic account-call verification. No sender or authority issuer. */
+import { type Hex, type PublicClient } from 'viem';
+import { z } from 'zod';
+import { type LpUserOpTerms } from './lp-userop-definition.js';
+import { type LpV3GuardDeployment } from './vendor/lp-v3/lp-v3-atomic-contract.js';
+import { type LpV3FinalityPolicy } from './vendor/lp-v3/lp-v3-atomic-read-contract.js';
+import { type LpV3CollectProtocolReadClient } from './vendor/lp-v3/lp-v3-collect-protocol-index.js';
+export declare const LP_USEROP_BATCH_ABI: readonly [{
+    readonly name: "executeBatch";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "target";
+        }, {
+            readonly type: "uint256";
+            readonly name: "value";
+        }, {
+            readonly type: "bytes";
+            readonly name: "data";
+        }];
+        readonly name: "calls";
+    }];
+    readonly outputs: readonly [];
+}];
+export declare const LP_USEROP_VERIFICATION_EVIDENCE_SCHEMA: z.ZodObject<{
+    baseline: z.ZodObject<{
+        chainId: z.ZodLiteral<8453>;
+        fee: z.ZodNumber;
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+        account: z.ZodString;
+        factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        blockTimestamp: z.ZodNumber;
+        manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+        token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+        token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+        usdcImplementation: z.ZodLiteral<"0x2ce6311ddae708829bc0784c967b7d77d19fd779">;
+        factoryCodeHash: z.ZodLiteral<`0x${string}`>;
+        managerCodeHash: z.ZodLiteral<`0x${string}`>;
+        token0CodeHash: z.ZodLiteral<`0x${string}`>;
+        token1CodeHash: z.ZodLiteral<`0x${string}`>;
+        usdcImplementationCodeHash: z.ZodLiteral<`0x${string}`>;
+        pool: z.ZodString;
+        balances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        allowances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        factoryPool: z.ZodString;
+        tick: z.ZodNumber;
+        observedAt: z.ZodNumber;
+        managerFactory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        usdcPaused: z.ZodLiteral<false>;
+        accountBlacklisted: z.ZodLiteral<false>;
+        managerBlacklisted: z.ZodLiteral<false>;
+        poolFactory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        tickSpacing: z.ZodNumber;
+        sqrtPriceX96: z.ZodString;
+        unlocked: z.ZodLiteral<true>;
+        position: 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>;
+            approved: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0x0000000000000000000000000000000000000000">]>;
+        }, z.core.$strict>;
+        managerNativeBalance: z.ZodString;
+        schemaVersion: z.ZodLiteral<3>;
+        accountCode: z.ZodString;
+        accountCodeHash: z.ZodString;
+        guard: z.ZodObject<{
+            address: z.ZodString;
+            runtimeCodeHash: z.ZodString;
+            configurationHash: z.ZodString;
+            deploymentChainId: z.ZodLiteral<8453>;
+            ownerApprovalForAll: z.ZodLiteral<false>;
+            guardBlacklisted: z.ZodLiteral<false>;
+            poolBlacklisted: z.ZodLiteral<false>;
+            tokenAllowances: z.ZodTuple<[z.ZodLiteral<"0">, z.ZodLiteral<"0">], null>;
+            tokenBalances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        planCommitment: z.ZodString;
+        intentCommitment: z.ZodString;
+        policyCommitment: z.ZodString;
+        baselineCommitment: z.ZodString;
+        checkedAt: z.ZodNumber;
+        checkCommitment: z.ZodString;
+        executionAuthorized: z.ZodLiteral<false>;
+        transportVerified: z.ZodLiteral<false>;
+        claimReleased: z.ZodLiteral<false>;
+        retainClaim: z.ZodLiteral<true>;
+        retrySafe: z.ZodLiteral<false>;
+        schemaVersion: z.ZodLiteral<3>;
+        kind: z.ZodLiteral<"lp-v3-collect-protocol-check">;
+    }, z.core.$strict>;
+    verifiedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+export type LpUserOpVerificationEvidence = z.infer<typeof LP_USEROP_VERIFICATION_EVIDENCE_SCHEMA>;
+export declare const LP_USEROP_SUBMIT_EVIDENCE_SCHEMA: z.ZodObject<{
+    baseline: z.ZodObject<{
+        chainId: z.ZodLiteral<8453>;
+        fee: z.ZodNumber;
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+        account: z.ZodString;
+        factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        blockTimestamp: z.ZodNumber;
+        manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+        token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+        token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+        usdcImplementation: z.ZodLiteral<"0x2ce6311ddae708829bc0784c967b7d77d19fd779">;
+        factoryCodeHash: z.ZodLiteral<`0x${string}`>;
+        managerCodeHash: z.ZodLiteral<`0x${string}`>;
+        token0CodeHash: z.ZodLiteral<`0x${string}`>;
+        token1CodeHash: z.ZodLiteral<`0x${string}`>;
+        usdcImplementationCodeHash: z.ZodLiteral<`0x${string}`>;
+        pool: z.ZodString;
+        balances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        allowances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        factoryPool: z.ZodString;
+        tick: z.ZodNumber;
+        observedAt: z.ZodNumber;
+        managerFactory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        usdcPaused: z.ZodLiteral<false>;
+        accountBlacklisted: z.ZodLiteral<false>;
+        managerBlacklisted: z.ZodLiteral<false>;
+        poolFactory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        tickSpacing: z.ZodNumber;
+        sqrtPriceX96: z.ZodString;
+        unlocked: z.ZodLiteral<true>;
+        position: 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>;
+            approved: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0x0000000000000000000000000000000000000000">]>;
+        }, z.core.$strict>;
+        managerNativeBalance: z.ZodString;
+        schemaVersion: z.ZodLiteral<3>;
+        accountCode: z.ZodString;
+        accountCodeHash: z.ZodString;
+        guard: z.ZodObject<{
+            address: z.ZodString;
+            runtimeCodeHash: z.ZodString;
+            configurationHash: z.ZodString;
+            deploymentChainId: z.ZodLiteral<8453>;
+            ownerApprovalForAll: z.ZodLiteral<false>;
+            guardBlacklisted: z.ZodLiteral<false>;
+            poolBlacklisted: z.ZodLiteral<false>;
+            tokenAllowances: z.ZodTuple<[z.ZodLiteral<"0">, z.ZodLiteral<"0">], null>;
+            tokenBalances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        planCommitment: z.ZodString;
+        intentCommitment: z.ZodString;
+        policyCommitment: z.ZodString;
+        baselineCommitment: z.ZodString;
+        checkedAt: z.ZodNumber;
+        checkCommitment: z.ZodString;
+        executionAuthorized: z.ZodLiteral<false>;
+        transportVerified: z.ZodLiteral<false>;
+        claimReleased: z.ZodLiteral<false>;
+        retainClaim: z.ZodLiteral<true>;
+        retrySafe: z.ZodLiteral<false>;
+        schemaVersion: z.ZodLiteral<3>;
+        kind: z.ZodLiteral<"lp-v3-collect-protocol-check">;
+    }, z.core.$strict>;
+    verifiedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+export type LpUserOpSubmitEvidence = LpUserOpVerificationEvidence;
+export declare const LP_USEROP_ENVELOPE_SCHEMA: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"lp-collect-userop">;
+    input: 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>;
+        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;
+        nftApprovalPolicy: z.ZodLiteral<"zero-before-and-after">;
+        guardDeploymentId: z.ZodLiteral<"base-weth-usdc-collect-v1">;
+        schemaVersion: z.ZodLiteral<3>;
+    }, z.core.$strict>;
+    plan: z.ZodObject<{
+        intent: 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>;
+            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;
+            nftApprovalPolicy: z.ZodLiteral<"zero-before-and-after">;
+            guardDeploymentId: z.ZodLiteral<"base-weth-usdc-collect-v1">;
+            schemaVersion: z.ZodLiteral<3>;
+        }, z.core.$strict>;
+        intentCommitment: z.ZodString;
+        policyCommitment: z.ZodString;
+        guardDeployment: z.ZodObject<{
+            id: z.ZodLiteral<"base-weth-usdc-collect-v1">;
+            chainId: z.ZodLiteral<8453>;
+            address: z.ZodString;
+            runtimeCodeHash: z.ZodString;
+            configurationHash: z.ZodLiteral<`0x${string}`>;
+            codeVersion: z.ZodLiteral<"OttoV3CollectGuard-v1">;
+            deploymentBlock: z.ZodString;
+            reviewReference: z.ZodString;
+        }, z.core.$strict>;
+        calls: z.ZodTuple<[z.ZodObject<{
+            step: z.ZodEnum<{
+                mutation: "mutation";
+                "erc20-approve": "erc20-approve";
+                "erc20-cleanup": "erc20-cleanup";
+                "nft-approve": "nft-approve";
+                "nft-clear": "nft-clear";
+            }>;
+            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>, z.ZodObject<{
+            step: z.ZodEnum<{
+                mutation: "mutation";
+                "erc20-approve": "erc20-approve";
+                "erc20-cleanup": "erc20-cleanup";
+                "nft-approve": "nft-approve";
+                "nft-clear": "nft-clear";
+            }>;
+            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>], null>;
+        preparedBlock: z.ZodObject<{
+            number: z.ZodString;
+            hash: z.ZodString;
+        }, z.core.$strict>;
+        preparedObservationCommitment: z.ZodString;
+        planCommitment: z.ZodString;
+        executionAuthorized: z.ZodLiteral<false>;
+        transportVerified: z.ZodLiteral<false>;
+        claimReleased: z.ZodLiteral<false>;
+        retainClaim: z.ZodLiteral<true>;
+        retrySafe: z.ZodLiteral<false>;
+        schemaVersion: z.ZodLiteral<3>;
+        kind: z.ZodLiteral<"lp-v3-collect-protocol">;
+    }, z.core.$strict>;
+    baseline: z.ZodObject<{
+        chainId: z.ZodLiteral<8453>;
+        fee: z.ZodNumber;
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+        account: z.ZodString;
+        factory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        blockTimestamp: z.ZodNumber;
+        manager: z.ZodLiteral<"0x03a520b32c04bf3beef7beb72e919cf822ed34f1">;
+        token0: z.ZodLiteral<"0x4200000000000000000000000000000000000006">;
+        token1: z.ZodLiteral<"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913">;
+        usdcImplementation: z.ZodLiteral<"0x2ce6311ddae708829bc0784c967b7d77d19fd779">;
+        factoryCodeHash: z.ZodLiteral<`0x${string}`>;
+        managerCodeHash: z.ZodLiteral<`0x${string}`>;
+        token0CodeHash: z.ZodLiteral<`0x${string}`>;
+        token1CodeHash: z.ZodLiteral<`0x${string}`>;
+        usdcImplementationCodeHash: z.ZodLiteral<`0x${string}`>;
+        pool: z.ZodString;
+        balances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        allowances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        factoryPool: z.ZodString;
+        tick: z.ZodNumber;
+        observedAt: z.ZodNumber;
+        managerFactory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        usdcPaused: z.ZodLiteral<false>;
+        accountBlacklisted: z.ZodLiteral<false>;
+        managerBlacklisted: z.ZodLiteral<false>;
+        poolFactory: z.ZodLiteral<"0x33128a8fc17869897dce68ed026d694621f6fdfd">;
+        tickSpacing: z.ZodNumber;
+        sqrtPriceX96: z.ZodString;
+        unlocked: z.ZodLiteral<true>;
+        position: 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>;
+            approved: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0x0000000000000000000000000000000000000000">]>;
+        }, z.core.$strict>;
+        managerNativeBalance: z.ZodString;
+        schemaVersion: z.ZodLiteral<3>;
+        accountCode: z.ZodString;
+        accountCodeHash: z.ZodString;
+        guard: z.ZodObject<{
+            address: z.ZodString;
+            runtimeCodeHash: z.ZodString;
+            configurationHash: z.ZodString;
+            deploymentChainId: z.ZodLiteral<8453>;
+            ownerApprovalForAll: z.ZodLiteral<false>;
+            guardBlacklisted: z.ZodLiteral<false>;
+            poolBlacklisted: z.ZodLiteral<false>;
+            tokenAllowances: z.ZodTuple<[z.ZodLiteral<"0">, z.ZodLiteral<"0">], null>;
+            tokenBalances: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        planCommitment: z.ZodString;
+        intentCommitment: z.ZodString;
+        policyCommitment: z.ZodString;
+        baselineCommitment: z.ZodString;
+        checkedAt: z.ZodNumber;
+        checkCommitment: z.ZodString;
+        executionAuthorized: z.ZodLiteral<false>;
+        transportVerified: z.ZodLiteral<false>;
+        claimReleased: z.ZodLiteral<false>;
+        retainClaim: z.ZodLiteral<true>;
+        retrySafe: z.ZodLiteral<false>;
+        schemaVersion: z.ZodLiteral<3>;
+        kind: z.ZodLiteral<"lp-v3-collect-protocol-check">;
+    }, z.core.$strict>;
+    terms: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        ruleset: z.ZodLiteral<"lp-guarded-collect-userop-v1">;
+        userId: z.ZodString;
+        account: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        chainId: z.ZodLiteral<8453>;
+        authorityDigest: z.ZodString;
+        lpActivationCommitment: z.ZodString;
+        sponsoredActivationId: z.ZodString;
+        sponsoredActivationDigest: z.ZodString;
+        projectId: z.ZodString;
+        policyId: z.ZodString;
+        policyRulesDigest: z.ZodString;
+        providerEnforcementEvidenceDigest: z.ZodString;
+        providerEndpoint: z.ZodLiteral<"cdp-end-user-smart-account-send-v1">;
+        guardDeployment: z.ZodObject<{
+            id: z.ZodLiteral<"base-weth-usdc-collect-v1">;
+            chainId: z.ZodLiteral<8453>;
+            address: z.ZodString;
+            runtimeCodeHash: z.ZodString;
+            configurationHash: z.ZodLiteral<`0x${string}`>;
+            codeVersion: z.ZodLiteral<"OttoV3CollectGuard-v1">;
+            deploymentBlock: z.ZodString;
+            reviewReference: z.ZodString;
+        }, z.core.$strict>;
+        finalityPolicy: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            id: z.ZodLiteral<"base-finalized-lp-v1">;
+            chainId: z.ZodLiteral<8453>;
+            blockTag: z.ZodLiteral<"finalized">;
+            reviewReference: z.ZodString;
+            minFinalizedConfirmations: z.ZodNumber;
+            maxHeadAgeSeconds: z.ZodNumber;
+            maxFinalizedLagSeconds: z.ZodNumber;
+            maxReadDurationSeconds: z.ZodNumber;
+        }, z.core.$strict>;
+        delegate: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        delegateCodeHash: z.ZodString;
+        implementation: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        implementationCodeHash: z.ZodString;
+        delegateBatchAbi: z.ZodLiteral<"coinbase-executeBatch-v1">;
+        delegateBatchReviewDigest: z.ZodString;
+        entryPoint: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        entryPointCodeHash: z.ZodString;
+        entryPointVersion: z.ZodLiteral<"0.6">;
+        ownerProfile: z.ZodObject<{
+            kind: z.ZodLiteral<"sole-eoa-owner">;
+            nextOwnerIndex: z.ZodLiteral<"1">;
+            ownerCount: z.ZodLiteral<"1">;
+            ownerAtIndex0: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            spendPermissionsEnabled: z.ZodLiteral<false>;
+        }, z.core.$strict>;
+        paymaster: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        paymasterCodeHash: z.ZodString;
+        sponsorshipPolicyId: z.ZodString;
+        maxGasCostWei: z.ZodString;
+        maxUserGasCostWei: z.ZodString;
+        maxTotalGasCostWei: z.ZodString;
+        maximumCollectAtomic: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+        intentCommitment: z.ZodString;
+        reviewCreatedAtMs: z.ZodNumber;
+        reviewExpiresAtMs: z.ZodNumber;
+        initialNftApproval: z.ZodLiteral<"0x0000000000000000000000000000000000000000">;
+        finalNftApproval: z.ZodLiteral<"0x0000000000000000000000000000000000000000">;
+        execution: z.ZodLiteral<"atomic-nft-approve-guarded-collect">;
+        principalDebitAuthorized: z.ZodLiteral<false>;
+    }, z.core.$strict>;
+    finalityPolicy: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodLiteral<"base-finalized-lp-v1">;
+        chainId: z.ZodLiteral<8453>;
+        blockTag: z.ZodLiteral<"finalized">;
+        reviewReference: z.ZodString;
+        minFinalizedConfirmations: z.ZodNumber;
+        maxHeadAgeSeconds: z.ZodNumber;
+        maxFinalizedLagSeconds: z.ZodNumber;
+        maxReadDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    preparedAtMs: z.ZodNumber;
+    validUntilMs: z.ZodNumber;
+    commitment: z.ZodString;
+}, z.core.$strict>;
+export type LpUserOpEnvelope = z.infer<typeof LP_USEROP_ENVELOPE_SCHEMA>;
+export interface LpUserOpRuntime {
+    readonly client: PublicClient;
+    /** Immutable startup policy, independently selected by the host. No request override. */
+    readonly guardDeployments: readonly LpV3GuardDeployment[];
+    readonly finalityPolicy: LpV3FinalityPolicy;
+    readonly nowMs?: () => number;
+}
+export interface VerifiedLpUserOp {
+    readonly envelope: LpUserOpEnvelope;
+    readonly verificationOnly: true;
+}
+export declare class LpUserOpError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare function requireLpUserOp(value: unknown, code: string): asserts value;
+export declare function lpUserOpNow(runtime: LpUserOpRuntime): number;
+/** Preserve the canonical library's EIP-1898 request objects through viem's custom RPC schema. */
+export declare function lpUserOpProtocolClient(client: PublicClient): LpV3CollectProtocolReadClient;
+export declare function lpUserOpProtocol(runtime: LpUserOpRuntime, envelope?: LpUserOpEnvelope): 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: import("./vendor/lp-v3/lp-v3-collect-protocol-observation.js").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?: import("./vendor/lp-v3/lp-v3-plan.js").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?: import("./vendor/lp-v3/lp-v3-plan.js").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?: import("./vendor/lp-v3/lp-v3-plan.js").LpV3VerifyOptions) => import("./vendor/lp-v3/lp-v3-collect-protocol-contract.js").LpV3CollectProtocolAccounting;
+}>;
+/** Bound every awaited read phase with both clocks; event-loop pauses cannot bypass the timer. */
+export declare function boundedLpUserOpRead<T>(runtime: LpUserOpRuntime, work: () => Promise<T>): Promise<T>;
+/** Durable-record validation is not freshness, transport, execution or claim-release authority. */
+export declare function assertLpUserOpEnvelope(raw: unknown): LpUserOpEnvelope;
+export declare function assertLpUserOpAccountState(runtime: LpUserOpRuntime, terms: LpUserOpTerms, blockNumber: bigint, blockHash: Hex): Promise<void>;
+export declare function prepareLpUserOp(runtime: LpUserOpRuntime, rawInput: unknown, independentTerms: LpUserOpTerms): Promise<LpUserOpEnvelope>;
+export declare function verifyLpUserOp(runtime: LpUserOpRuntime, rawEnvelope: unknown, independentTerms: LpUserOpTerms): Promise<VerifiedLpUserOp>;
+export declare function assertVerifiedLpUserOp(value: VerifiedLpUserOp): LpUserOpEnvelope;
+/** Final read-age boundary after every blocking writer lock and immediately before provider start. */
+export declare function assertFreshVerifiedLpUserOp(value: VerifiedLpUserOp, nowMs: number): void;
+export declare function lpUserOpVerificationEvidence(value: VerifiedLpUserOp): LpUserOpVerificationEvidence;
+export declare function lpUserOpCalls(value: VerifiedLpUserOp): {
+    to: string;
+    data: string;
+    value: "0";
+}[];
+/** Exact persisted request reconstruction after Stop or expiry; conveys no new sending authority. */
+export declare function lpUserOpRecordedCalls(rawEnvelope: LpUserOpEnvelope): {
+    to: string;
+    data: string;
+    value: "0";
+}[];
+export declare function lpUserOpBatchData(envelope: LpUserOpEnvelope): Hex;
+/** Entire reviewed executeBatch, called from the EntryPoint at the verified block, without overrides. */
+export declare function simulateLpUserOp(runtime: LpUserOpRuntime, envelope: LpUserOpEnvelope, independentTerms: LpUserOpTerms): Promise<VerifiedLpUserOp>;