otto-intel-mcp 0.1.2 → 0.1.4

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

@@ -0,0 +1,445 @@
+import { z } from 'zod';
+import { type LpV3Intent, type LpV3ChainEvidence } from './lp-v3-contract.js';
+export declare const LP_V3_COLLECT_GUARD_ID = "base-weth-usdc-collect-v1";
+export declare const LP_V3_COLLECT_CONFIGURATION_HASH: `0x${string}`;
+export declare const lpV3GuardDeploymentSchema: 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>;
+export type LpV3GuardDeployment = z.infer<typeof lpV3GuardDeploymentSchema>;
+/** No guard is deployed/activated by this library. A host may supply a separately
+ * reviewed manifest at startup. Never deserialize this policy from an agent/API plan.
+ */
+export declare const DEFAULT_LP_V3_COLLECT_GUARDS: readonly LpV3GuardDeployment[];
+export declare function reviewedGuardPolicy(input?: readonly LpV3GuardDeployment[]): readonly LpV3GuardDeployment[];
+export declare const lpV3AtomicIntentSchema: z.ZodDiscriminatedUnion<[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>;
+    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;
+    schemaVersion: z.ZodLiteral<2>;
+    nftApprovalPolicy: z.ZodLiteral<"zero-before-and-after">;
+}, 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>;
+    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;
+    schemaVersion: z.ZodLiteral<2>;
+    nftApprovalPolicy: z.ZodLiteral<"zero-before-and-after">;
+    guardDeploymentId: z.ZodLiteral<"base-weth-usdc-collect-v1">;
+}, z.core.$strict>], "action">;
+export type LpV3AtomicIntent = z.infer<typeof lpV3AtomicIntentSchema>;
+export declare const lpV3AtomicPositionSchema: 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>;
+export declare const lpV3AtomicGuardEvidenceSchema: 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>;
+export declare const lpV3AtomicChainEvidenceSchema: z.ZodObject<{
+    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>;
+    schemaVersion: z.ZodLiteral<2>;
+    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;
+    guard: z.ZodNullable<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>;
+export type LpV3AtomicChainEvidence = z.infer<typeof lpV3AtomicChainEvidenceSchema>;
+export declare const lpV3AtomicCallSchema: 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>;
+export type LpV3AtomicCall = z.infer<typeof lpV3AtomicCallSchema>;
+export declare const lpV3AtomicPlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    kind: z.ZodLiteral<"lp-v3-atomic">;
+    intent: z.ZodDiscriminatedUnion<[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>;
+        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;
+        schemaVersion: z.ZodLiteral<2>;
+        nftApprovalPolicy: z.ZodLiteral<"zero-before-and-after">;
+    }, 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>;
+        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;
+        schemaVersion: z.ZodLiteral<2>;
+        nftApprovalPolicy: z.ZodLiteral<"zero-before-and-after">;
+        guardDeploymentId: z.ZodLiteral<"base-weth-usdc-collect-v1">;
+    }, z.core.$strict>], "action">;
+    signingSupport: z.ZodLiteral<"HOST_GATES_REQUIRED">;
+    intentCommitment: z.ZodString;
+    calls: z.ZodArray<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>>;
+    recoveryCalls: z.ZodArray<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>>;
+    guardDeployment: z.ZodNullable<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>>;
+    preparedBlock: z.ZodObject<{
+        number: z.ZodString;
+        hash: z.ZodString;
+    }, z.core.$strict>;
+    planCommitment: z.ZodString;
+}, z.core.$strict>;
+export type LpV3AtomicPlan = z.infer<typeof lpV3AtomicPlanSchema>;
+export declare const LP_V3_ATOMIC_NPM_ABI: readonly [{
+    readonly name: "multicall";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "bytes[]";
+        readonly name: "data";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bytes[]";
+        readonly name: "results";
+    }];
+}, {
+    readonly name: "transferFrom";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "from";
+    }, {
+        readonly type: "address";
+        readonly name: "to";
+    }, {
+        readonly type: "uint256";
+        readonly name: "tokenId";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "to";
+    }, {
+        readonly type: "uint256";
+        readonly name: "tokenId";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "getApproved";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "tokenId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "isApprovedForAll";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "address";
+        readonly name: "operator";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "Approval";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "approved";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "tokenId";
+        readonly indexed: true;
+    }];
+}, {
+    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_COLLECT_GUARD_ABI: readonly [{
+    readonly name: "collect";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "owner";
+        }, {
+            readonly type: "address";
+            readonly name: "pool";
+        }, {
+            readonly type: "uint256";
+            readonly name: "tokenId";
+        }, {
+            readonly type: "int24";
+            readonly name: "tickLower";
+        }, {
+            readonly type: "int24";
+            readonly name: "tickUpper";
+        }, {
+            readonly type: "uint128";
+            readonly name: "amount0Max";
+        }, {
+            readonly type: "uint128";
+            readonly name: "amount1Max";
+        }, {
+            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: "configurationHash";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bytes32";
+    }];
+}, {
+    readonly name: "deploymentChainId";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "Collected";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "pool";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "tokenId";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount0";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount1";
+    }];
+}];
+export declare function legacyIntent(intent: LpV3AtomicIntent): LpV3Intent;
+export declare function legacyEvidence(evidence: LpV3AtomicChainEvidence): LpV3ChainEvidence;
+export declare function resolveCollectGuard(intent: LpV3AtomicIntent, policy: readonly LpV3GuardDeployment[]): LpV3GuardDeployment | null;

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

@@ -0,0 +1,90 @@
+import { encodeAbiParameters, keccak256, parseAbi, parseAbiParameters } from 'viem';
+import { z } from 'zod';
+import { LP_V3_BASE as B, lpAddress, lpHash, lpUint, lpV3IntentSchema, lpV3ChainEvidenceSchema, lpV3PositionSchema, deepFreeze, } from './lp-v3-contract.js';
+const zero = '0x0000000000000000000000000000000000000000';
+export const LP_V3_COLLECT_GUARD_ID = 'base-weth-usdc-collect-v1';
+export const LP_V3_COLLECT_CONFIGURATION_HASH = keccak256(encodeAbiParameters(parseAbiParameters('uint256,address,address,address,address,address,bytes32,bytes32,bytes32,bytes32,bytes32'), [8453n, B.manager, B.factory, B.token0, B.token1, B.usdcImplementation, B.factoryCodeHash, B.managerCodeHash, B.token0CodeHash, B.token1CodeHash, B.usdcImplementationCodeHash]));
+export const lpV3GuardDeploymentSchema = z.object({
+    id: z.literal(LP_V3_COLLECT_GUARD_ID), chainId: z.literal(8453),
+    address: lpAddress.refine(v => ![B.manager, B.factory, B.token0, B.token1].some(a => a === v)),
+    runtimeCodeHash: lpHash, configurationHash: z.literal(LP_V3_COLLECT_CONFIGURATION_HASH),
+    codeVersion: z.literal('OttoV3CollectGuard-v1'),
+    deploymentBlock: lpUint(), reviewReference: z.string().min(16).max(200),
+}).strict();
+/** No guard is deployed/activated by this library. A host may supply a separately
+ * reviewed manifest at startup. Never deserialize this policy from an agent/API plan.
+ */
+export const DEFAULT_LP_V3_COLLECT_GUARDS = Object.freeze([]);
+export function reviewedGuardPolicy(input = DEFAULT_LP_V3_COLLECT_GUARDS) {
+    const policy = z.array(lpV3GuardDeploymentSchema).max(1).parse(input);
+    return deepFreeze(policy);
+}
+const approvalPolicy = z.literal('zero-before-and-after');
+export const lpV3AtomicIntentSchema = z.discriminatedUnion('action', [
+    lpV3IntentSchema.options[1].extend({ schemaVersion: z.literal(2), nftApprovalPolicy: approvalPolicy }).strict(),
+    lpV3IntentSchema.options[3].extend({ schemaVersion: z.literal(2), nftApprovalPolicy: approvalPolicy, guardDeploymentId: z.literal(LP_V3_COLLECT_GUARD_ID) }).strict(),
+]);
+export const lpV3AtomicPositionSchema = lpV3PositionSchema.extend({ approved: z.union([lpAddress, z.literal(zero)]) }).strict();
+export const lpV3AtomicGuardEvidenceSchema = z.object({
+    address: lpAddress, runtimeCodeHash: lpHash, configurationHash: lpHash,
+    deploymentChainId: z.literal(8453), ownerApprovalForAll: z.literal(false),
+    guardBlacklisted: z.literal(false), poolBlacklisted: z.literal(false),
+    tokenAllowances: z.tuple([z.literal('0'), z.literal('0')]),
+    tokenBalances: z.tuple([lpUint(), lpUint()]),
+}).strict();
+export const lpV3AtomicChainEvidenceSchema = lpV3ChainEvidenceSchema.extend({
+    schemaVersion: z.literal(2), position: lpV3AtomicPositionSchema,
+    managerNativeBalance: lpUint(),
+    guard: lpV3AtomicGuardEvidenceSchema.nullable(),
+}).strict();
+export const lpV3AtomicCallSchema = z.object({
+    step: z.enum(['erc20-approve', 'mutation', 'erc20-cleanup', 'nft-approve', 'nft-clear']),
+    tokenIndex: z.union([z.literal(0), z.literal(1)]).nullable(),
+    chainId: z.literal(8453), from: lpAddress, to: lpAddress, value: z.literal('0'),
+    data: z.string().regex(/^0x[0-9a-f]+$/),
+}).strict();
+export const lpV3AtomicPlanSchema = z.object({
+    schemaVersion: z.literal(2), kind: z.literal('lp-v3-atomic'), intent: lpV3AtomicIntentSchema,
+    signingSupport: z.literal('HOST_GATES_REQUIRED'), intentCommitment: lpHash,
+    calls: z.array(lpV3AtomicCallSchema).min(2).max(5),
+    // Recovery is permission cleanup only, and belongs to the ORIGINAL durable claim.
+    // These are not an additional normal execution sequence or a retry authorization.
+    recoveryCalls: z.array(lpV3AtomicCallSchema).max(2),
+    guardDeployment: lpV3GuardDeploymentSchema.nullable(),
+    preparedBlock: z.object({ number: lpUint(), hash: lpHash }).strict(), planCommitment: lpHash,
+}).strict();
+export const LP_V3_ATOMIC_NPM_ABI = parseAbi([
+    'function multicall(bytes[] data) payable returns (bytes[] results)',
+    'function transferFrom(address from,address to,uint256 tokenId)',
+    'function approve(address to,uint256 tokenId)',
+    'function getApproved(uint256 tokenId) view returns (address)',
+    'function isApprovedForAll(address owner,address operator) view returns (bool)',
+    'event Approval(address indexed owner,address indexed approved,uint256 indexed tokenId)',
+    'event Transfer(address indexed from,address indexed to,uint256 indexed tokenId)',
+]);
+export const LP_V3_COLLECT_GUARD_ABI = parseAbi([
+    'function collect((address owner,address pool,uint256 tokenId,int24 tickLower,int24 tickUpper,uint128 amount0Max,uint128 amount1Max,uint256 amount0Min,uint256 amount1Min,uint256 deadline) params) returns (uint256 amount0,uint256 amount1)',
+    'function configurationHash() view returns (bytes32)',
+    'function deploymentChainId() view returns (uint256)',
+    'event Collected(address indexed owner,address indexed pool,uint256 indexed tokenId,uint256 amount0,uint256 amount1)',
+]);
+export function legacyIntent(intent) {
+    const { nftApprovalPolicy: _, schemaVersion: __, ...body } = intent;
+    const raw = { ...body, schemaVersion: 1 };
+    delete raw.guardDeploymentId;
+    return lpV3IntentSchema.parse(raw);
+}
+export function legacyEvidence(evidence) {
+    const { guard: _, schemaVersion: __, position, managerNativeBalance: ____, ...body } = evidence;
+    const { approved: ___, ...p } = position;
+    return lpV3ChainEvidenceSchema.parse({ ...body, schemaVersion: 1, position: p });
+}
+export function resolveCollectGuard(intent, policy) {
+    if (intent.action === 'increase')
+        return null;
+    const deployment = policy.find(d => d.id === intent.guardDeploymentId);
+    if (!deployment)
+        throw new Error('LP_ATOMIC_COLLECT_GUARD_NOT_DEPLOYED');
+    return deployment;
+}
+//# sourceMappingURL=lp-v3-atomic-contract.js.map

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

@@ -0,0 +1,14 @@
+import { type LpV3EvidenceOptions, type LpV3ReadRequest } from './lp-v3-evidence.js';
+import { type LpV3AtomicIntent, type LpV3AtomicChainEvidence, type LpV3GuardDeployment } from './lp-v3-atomic-contract.js';
+export interface LpV3AtomicReadClient {
+    request(request: Omit<LpV3ReadRequest, 'method'> & {
+        method: LpV3ReadRequest['method'] | 'eth_getBalance';
+    }): Promise<unknown>;
+}
+export interface LpV3AtomicEvidenceOptions extends Omit<LpV3EvidenceOptions, 'client'> {
+    client?: LpV3AtomicReadClient;
+}
+/** The policy comes from the enclosing library's frozen host configuration.
+ * No additional token/NFT/guard read is allowed to escape the base evidence hash.
+ */
+export declare function collectLpV3AtomicEvidence(input: LpV3AtomicIntent, policy: readonly LpV3GuardDeployment[], options?: LpV3AtomicEvidenceOptions): Promise<LpV3AtomicChainEvidence>;

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

@@ -0,0 +1,82 @@
+import { createPublicClient, decodeFunctionResult, encodeFunctionData, http, keccak256, parseAbi } from 'viem';
+import { base } from 'viem/chains';
+import { LP_V3_BASE as B } from './lp-v3-contract.js';
+import { collectLpV3ChainEvidence } from './lp-v3-evidence.js';
+import { legacyIntent, lpV3AtomicIntentSchema, lpV3AtomicChainEvidenceSchema, lpV3AtomicGuardEvidenceSchema, resolveCollectGuard, } from './lp-v3-atomic-contract.js';
+const ABI = parseAbi([
+    '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)',
+    'function isBlacklisted(address account) view returns (bool)',
+    'function balanceOf(address account) view returns (uint256)',
+    'function allowance(address owner,address spender) view returns (uint256)',
+]);
+const validHex = (v) => typeof v === 'string' && /^0x(?:[0-9a-fA-F]{2})*$/.test(v);
+/** The policy comes from the enclosing library's frozen host configuration.
+ * No additional token/NFT/guard read is allowed to escape the base evidence hash.
+ */
+export async function collectLpV3AtomicEvidence(input, policy, options = {}) {
+    try {
+        const intent = lpV3AtomicIntentSchema.parse(input), deployment = resolveCollectGuard(intent, policy);
+        const original = options.client ?? createPublicClient({ chain: base, transport: http('https://mainnet.base.org', { timeout: 15_000, retryCount: 1 }) });
+        const positionCall = encodeFunctionData({ abi: ABI, functionName: 'positions', args: [BigInt(intent.tokenId)] });
+        let approved;
+        let queue = Promise.resolve();
+        const client = { request(request) {
+                const next = queue.then(async () => {
+                    const result = await original.request(request);
+                    const call = request.params?.[0];
+                    if (request.method === 'eth_call' && call?.to === B.manager && call.data === positionCall) {
+                        if (!validHex(result))
+                            throw new Error('LP_ATOMIC_NFT_APPROVAL_UNAVAILABLE');
+                        approved = decodeFunctionResult({ abi: ABI, functionName: 'positions', data: result })[1].toLowerCase();
+                    }
+                    return result;
+                });
+                queue = next.then(() => undefined, () => undefined);
+                return next;
+            } };
+        const evidence = await collectLpV3ChainEvidence(legacyIntent(intent), { ...options, client });
+        if (!evidence.position || approved === undefined)
+            throw new Error('LP_ATOMIC_NFT_APPROVAL_UNAVAILABLE');
+        const reference = { blockHash: evidence.blockHash, requireCanonical: true };
+        const managerNative = await client.request({ method: 'eth_getBalance', params: [B.manager, reference] });
+        if (typeof managerNative !== 'string' || !/^0x(?:0|[1-9a-fA-F][0-9a-fA-F]*)$/.test(managerNative))
+            throw new Error('LP_ATOMIC_NATIVE_BALANCE_UNAVAILABLE');
+        const managerNativeBalance = BigInt(managerNative).toString();
+        const read = async (target, functionName, args) => {
+            const data = encodeFunctionData({ abi: ABI, functionName, args });
+            const result = await client.request({ method: 'eth_call', params: [{ to: target, data }, reference] });
+            if (!validHex(result))
+                throw new Error('LP_ATOMIC_GUARD_STATE_UNAVAILABLE');
+            return decodeFunctionResult({ abi: ABI, functionName, data: result });
+        };
+        let guard = null;
+        if (deployment) {
+            const [code, configurationHash, deploymentChainId, ownerApprovalForAll, tokenAllowances, tokenBalances, guardBlacklisted, poolBlacklisted] = await Promise.all([
+                client.request({ method: 'eth_getCode', params: [deployment.address, reference] }),
+                read(deployment.address, 'configurationHash'), read(deployment.address, 'deploymentChainId'),
+                read(B.manager, 'isApprovedForAll', [intent.account, deployment.address]),
+                Promise.all([B.token0, B.token1].map(token => read(token, 'allowance', [deployment.address, B.manager]))),
+                Promise.all([B.token0, B.token1].map(token => read(token, 'balanceOf', [deployment.address]))),
+                read(B.token1, 'isBlacklisted', [deployment.address]), read(B.token1, 'isBlacklisted', [intent.pool]),
+            ]);
+            if (!validHex(code) || code === '0x' || typeof deploymentChainId !== 'bigint' || deploymentChainId !== 8453n || keccak256(code) !== deployment.runtimeCodeHash || configurationHash !== deployment.configurationHash)
+                throw new Error('LP_ATOMIC_GUARD_PIN_MISMATCH');
+            guard = lpV3AtomicGuardEvidenceSchema.parse({ address: deployment.address, runtimeCodeHash: keccak256(code), configurationHash, deploymentChainId: 8453, ownerApprovalForAll, tokenAllowances: tokenAllowances.map(String), tokenBalances: tokenBalances.map(String), guardBlacklisted, poolBlacklisted });
+        }
+        const anchor = await client.request({ method: 'eth_getBlockByNumber', params: [`0x${BigInt(evidence.blockNumber).toString(16)}`, false] });
+        const chain = await client.request({ method: 'eth_chainId' });
+        if (!anchor || anchor.hash !== evidence.blockHash || typeof anchor.number !== 'string' || BigInt(anchor.number) !== BigInt(evidence.blockNumber) || typeof anchor.timestamp !== 'string' || BigInt(anchor.timestamp) !== BigInt(evidence.blockTimestamp) || typeof chain !== 'string' || BigInt(chain) !== 8453n)
+            throw new Error('LP_ATOMIC_BLOCK_REORG');
+        const observedAt = (options.nowSeconds ?? (() => Math.floor(Date.now() / 1000)))();
+        if (!Number.isSafeInteger(observedAt) || observedAt < evidence.observedAt || evidence.blockTimestamp > observedAt || observedAt - evidence.blockTimestamp > (options.maxBlockAgeSeconds ?? 60))
+            throw new Error('LP_ATOMIC_STALE_EVIDENCE');
+        return lpV3AtomicChainEvidenceSchema.parse({ ...evidence, schemaVersion: 2, observedAt, position: { ...evidence.position, approved }, managerNativeBalance, guard });
+    }
+    catch {
+        // The RPC adapter may contain endpoint credentials; expose a bounded error only.
+        throw new Error('LP_ATOMIC_REQUIRED_CHAIN_STATE_UNAVAILABLE');
+    }
+}
+//# sourceMappingURL=lp-v3-atomic-evidence.js.map