otto-intel-mcp 0.1.2 → 0.1.4

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

@@ -0,0 +1,80 @@
+import { type LpV3AtomicEvidenceOptions } from './lp-v3-atomic-evidence.js';
+import type { LpV3GuardDeployment, LpV3AtomicIntent } from './lp-v3-atomic-contract.js';
+import type { LpV3AtomicSettlementContext } from './lp-v3-atomic-plan.js';
+import type { LpV3VerifyOptions } from './lp-v3-plan.js';
+/** Independently reviewed guard manifests are immutable HOST configuration.
+ * Default empty policy keeps guard collection unavailable; no deployment is implied.
+ * This library starts no transport, signer, operation journal or background worker.
+ */
+export declare function createLpV3AtomicLibrary(guardDeployments?: readonly LpV3GuardDeployment[]): Readonly<{
+    prepare: (input: unknown, chainEvidence: unknown, options?: LpV3VerifyOptions) => import("./lp-v3-atomic-contract.js").LpV3AtomicPlan;
+    verify: (input: unknown, independentIntent: unknown, freshEvidence: unknown, options?: LpV3VerifyOptions) => import("./lp-v3-atomic-plan.js").VerifiedLpV3AtomicPlan;
+    verifyForSettlement: (input: unknown, journalIntent: unknown, historicalBaseline: unknown, canonicalReadback: unknown, options?: LpV3VerifyOptions) => import("./lp-v3-atomic-plan.js").VerifiedLpV3AtomicSettlementContext;
+    collectEvidence: (intent: LpV3AtomicIntent, options?: LpV3AtomicEvidenceOptions) => Promise<{
+        chainId: 8453;
+        blockNumber: string;
+        blockHash: string;
+        blockTimestamp: number;
+        observedAt: number;
+        canonical: true;
+        account: string;
+        accountCode: "0x";
+        balances: [string, string];
+        allowances: [string, string];
+        manager: "0x03a520b32c04bf3beef7beb72e919cf822ed34f1";
+        managerFactory: "0x33128a8fc17869897dce68ed026d694621f6fdfd";
+        factory: "0x33128a8fc17869897dce68ed026d694621f6fdfd";
+        factoryPool: string;
+        factoryCodeHash: `0x${string}`;
+        managerCodeHash: `0x${string}`;
+        token0CodeHash: `0x${string}`;
+        token1CodeHash: `0x${string}`;
+        usdcImplementation: "0x2ce6311ddae708829bc0784c967b7d77d19fd779";
+        usdcImplementationCodeHash: `0x${string}`;
+        usdcPaused: false;
+        accountBlacklisted: false;
+        managerBlacklisted: false;
+        pool: string;
+        poolFactory: "0x33128a8fc17869897dce68ed026d694621f6fdfd";
+        token0: "0x4200000000000000000000000000000000000006";
+        token1: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+        fee: number;
+        tickSpacing: number;
+        tick: number;
+        sqrtPriceX96: string;
+        unlocked: true;
+        schemaVersion: 2;
+        position: {
+            tokenId: string;
+            owner: string;
+            token0: string;
+            token1: string;
+            fee: number;
+            tickLower: number;
+            tickUpper: number;
+            liquidity: string;
+            tokensOwed: [string, string];
+            approved: string;
+        };
+        managerNativeBalance: string;
+        guard: {
+            address: string;
+            runtimeCodeHash: string;
+            configurationHash: string;
+            deploymentChainId: 8453;
+            ownerApprovalForAll: false;
+            guardBlacklisted: false;
+            poolBlacklisted: false;
+            tokenAllowances: ["0", "0"];
+            tokenBalances: [string, string];
+        } | null;
+    }>;
+    verifySettlement: (context: LpV3AtomicSettlementContext, evidence: unknown, options?: LpV3VerifyOptions) => import("./lp-v3-atomic-settlement.js").LpV3AtomicSettlementResult;
+}>;
+export { lpV3AtomicIntentSchema, lpV3AtomicPlanSchema, lpV3AtomicChainEvidenceSchema, DEFAULT_LP_V3_COLLECT_GUARDS, LP_V3_COLLECT_CONFIGURATION_HASH } from './lp-v3-atomic-contract.js';
+export type { LpV3AtomicIntent, LpV3AtomicPlan, LpV3AtomicCall, LpV3AtomicChainEvidence, LpV3GuardDeployment } from './lp-v3-atomic-contract.js';
+export { requireVerifiedLpV3AtomicPlan } from './lp-v3-atomic-plan.js';
+export type { VerifiedLpV3AtomicPlan, VerifiedLpV3AtomicSettlementContext, LpV3AtomicSettlementContext } from './lp-v3-atomic-plan.js';
+export { lpV3AtomicSettlementEvidenceSchema } from './lp-v3-atomic-settlement.js';
+export type { LpV3AtomicSettlementEvidence, LpV3AtomicSettlementResult } from './lp-v3-atomic-settlement.js';
+export type { LpV3AtomicEvidenceOptions, LpV3AtomicReadClient } from './lp-v3-atomic-evidence.js';

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

@@ -0,0 +1,19 @@
+import { createLpV3AtomicPlanner } from './lp-v3-atomic-plan.js';
+import { collectLpV3AtomicEvidence } from './lp-v3-atomic-evidence.js';
+import { verifyLpV3AtomicSettlement } from './lp-v3-atomic-settlement.js';
+/** Independently reviewed guard manifests are immutable HOST configuration.
+ * Default empty policy keeps guard collection unavailable; no deployment is implied.
+ * This library starts no transport, signer, operation journal or background worker.
+ */
+export function createLpV3AtomicLibrary(guardDeployments) {
+    const planner = createLpV3AtomicPlanner(guardDeployments);
+    return Object.freeze({
+        prepare: planner.prepare, verify: planner.verify, verifyForSettlement: planner.verifyForSettlement,
+        collectEvidence: (intent, options) => collectLpV3AtomicEvidence(intent, planner.policy, options),
+        verifySettlement: (context, evidence, options) => verifyLpV3AtomicSettlement(context, evidence, planner.policy, options),
+    });
+}
+export { lpV3AtomicIntentSchema, lpV3AtomicPlanSchema, lpV3AtomicChainEvidenceSchema, DEFAULT_LP_V3_COLLECT_GUARDS, LP_V3_COLLECT_CONFIGURATION_HASH } from './lp-v3-atomic-contract.js';
+export { requireVerifiedLpV3AtomicPlan } from './lp-v3-atomic-plan.js';
+export { lpV3AtomicSettlementEvidenceSchema } from './lp-v3-atomic-settlement.js';
+//# sourceMappingURL=lp-v3-atomic-index.js.map

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

@@ -0,0 +1,43 @@
+import { type LpV3VerifyOptions } from './lp-v3-plan.js';
+import { type LpV3AtomicChainEvidence, type LpV3AtomicPlan, type LpV3GuardDeployment } from './lp-v3-atomic-contract.js';
+declare const atomicBrand: unique symbol;
+export interface VerifiedLpV3AtomicPlan {
+    readonly [atomicBrand]: true;
+    readonly plan: LpV3AtomicPlan;
+    readonly purpose: 'execute';
+    readonly evidence: LpV3AtomicChainEvidence;
+    readonly verifiedAt: number;
+}
+declare const settlementBrand: unique symbol;
+export interface VerifiedLpV3AtomicSettlementContext {
+    readonly [settlementBrand]: true;
+    readonly purpose: 'settle-only';
+    readonly plan: LpV3AtomicPlan;
+    readonly evidence: LpV3AtomicChainEvidence;
+    readonly verifiedAt: number;
+}
+export type LpV3AtomicSettlementContext = VerifiedLpV3AtomicPlan | VerifiedLpV3AtomicSettlementContext;
+export declare function requireVerifiedLpV3AtomicPlan(verified: VerifiedLpV3AtomicPlan, policy: readonly LpV3GuardDeployment[]): void;
+export declare function requireLpV3AtomicSettlementContext(context: LpV3AtomicSettlementContext, policy: readonly LpV3GuardDeployment[]): void;
+/** A frozen policy is an independently reviewed HOST configuration. It is not
+ * wallet authority and must never be accepted alongside an external request. */
+export declare function createLpV3AtomicPlanner(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;
+    }[];
+    prepare(input: unknown, chainEvidence: unknown, options?: LpV3VerifyOptions): LpV3AtomicPlan;
+    verify(input: unknown, independentIntent: unknown, freshEvidence: unknown, options?: LpV3VerifyOptions): VerifiedLpV3AtomicPlan;
+    /** Recovery-only reconstruction from the protected journal's ORIGINAL baseline.
+     * The host must independently reread that historical block's canonical mapping.
+     * This separate brand cannot authorize calls, approvals or a new operation.
+     */
+    verifyForSettlement(input: unknown, journalIntent: unknown, historicalBaseline: unknown, canonicalReadback: unknown, options?: LpV3VerifyOptions): VerifiedLpV3AtomicSettlementContext;
+}>;
+export {};

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

@@ -0,0 +1,112 @@
+import { encodeFunctionData } from 'viem';
+import { z } from 'zod';
+import { canonicalJson, commitment, deepFreeze, LP_V3_BASE, lpHash, lpUint } from './lp-v3-contract.js';
+import { checkLpV3Context, prepareLpV3Plan } from './lp-v3-plan.js';
+import { LP_V3_ATOMIC_NPM_ABI, LP_V3_COLLECT_GUARD_ABI, legacyIntent, legacyEvidence, lpV3AtomicIntentSchema, lpV3AtomicChainEvidenceSchema, lpV3AtomicPlanSchema, reviewedGuardPolicy, resolveCollectGuard, } from './lp-v3-atomic-contract.js';
+const verifiedPolicies = new WeakMap();
+const settlementPolicies = new WeakMap();
+export function requireVerifiedLpV3AtomicPlan(verified, policy) {
+    if (!verified || verifiedPolicies.get(verified) !== commitment(policy))
+        throw new Error('LP_UNVERIFIED_ATOMIC_PLAN');
+}
+export function requireLpV3AtomicSettlementContext(context, policy) {
+    if (!context || (verifiedPolicies.get(context) !== commitment(policy) && settlementPolicies.get(context) !== commitment(policy)))
+        throw new Error('LP_UNVERIFIED_ATOMIC_SETTLEMENT_CONTEXT');
+}
+const baselineReadbackSchema = z.object({
+    operationId: z.string(), planCommitment: lpHash, canonical: z.literal(true),
+    blockNumber: lpUint(), blockHash: lpHash,
+    originalVerifiedAt: z.number().int().positive().safe(), canonicalCheckedAt: z.number().int().positive().safe(),
+}).strict();
+function check(intent, evidence, policy, now) {
+    checkLpV3Context(legacyIntent(intent), legacyEvidence(evidence), now);
+    // Canonical NPM may spend existing native ETH for the WETH leg. Reject that
+    // known prestate; a later forced donation still requires settlement to fail shut.
+    if (intent.action === 'increase' && evidence.managerNativeBalance !== '0')
+        throw new Error('LP_NPM_NATIVE_BALANCE_REQUIRES_REVIEW');
+    if (evidence.position.approved !== '0x0000000000000000000000000000000000000000')
+        throw new Error('LP_EXISTING_NFT_APPROVAL_REQUIRES_RECOVERY');
+    const deployment = resolveCollectGuard(intent, policy);
+    if (!deployment) {
+        if (evidence.guard !== null)
+            throw new Error('LP_UNEXPECTED_GUARD_EVIDENCE');
+    }
+    else {
+        const g = evidence.guard;
+        if (!g || g.address !== deployment.address || g.runtimeCodeHash !== deployment.runtimeCodeHash || g.configurationHash !== deployment.configurationHash || BigInt(evidence.blockNumber) < BigInt(deployment.deploymentBlock))
+            throw new Error('LP_ATOMIC_GUARD_PIN_MISMATCH');
+    }
+    return deployment;
+}
+function derive(intent, evidence, deployment, now) {
+    const basePlan = prepareLpV3Plan(legacyIntent(intent), legacyEvidence(evidence), { now: () => now });
+    const call = (step, to, data) => ({ step, tokenIndex: null, chainId: 8453, from: intent.account, to, value: '0', data });
+    if (intent.action === 'increase') {
+        const selfTransfer = encodeFunctionData({ abi: LP_V3_ATOMIC_NPM_ABI, functionName: 'transferFrom', args: [intent.account, intent.account, BigInt(intent.tokenId)] });
+        const mutation = basePlan.calls.find(c => c.step === 'mutation');
+        const data = encodeFunctionData({ abi: LP_V3_ATOMIC_NPM_ABI, functionName: 'multicall', args: [[selfTransfer, mutation.data, selfTransfer]] });
+        const calls = basePlan.calls.map((c) => ({ ...c, step: c.step === 'approve' ? 'erc20-approve' : c.step === 'cleanup' ? 'erc20-cleanup' : 'mutation', data: c.step === 'mutation' ? data : c.data }));
+        return { calls, recoveryCalls: calls.filter(c => c.step === 'erc20-cleanup') };
+    }
+    if (!deployment)
+        throw new Error('LP_ATOMIC_COLLECT_GUARD_NOT_DEPLOYED');
+    const approve = (spender) => encodeFunctionData({ abi: LP_V3_ATOMIC_NPM_ABI, functionName: 'approve', args: [spender, BigInt(intent.tokenId)] });
+    return {
+        calls: [
+            call('nft-approve', LP_V3_BASE.manager, approve(deployment.address)),
+            call('mutation', deployment.address, 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) }] })),
+        ],
+        recoveryCalls: [call('nft-clear', LP_V3_BASE.manager, approve('0x0000000000000000000000000000000000000000'))],
+    };
+}
+function validate(input, independentIntent, chainEvidence, policy, at) {
+    const plan = lpV3AtomicPlanSchema.parse(input), intent = lpV3AtomicIntentSchema.parse(independentIntent), evidence = lpV3AtomicChainEvidenceSchema.parse(chainEvidence);
+    const deployment = check(intent, evidence, policy, at), sequence = derive(intent, evidence, deployment, at);
+    if (canonicalJson(intent) !== canonicalJson(plan.intent) || plan.intentCommitment !== commitment(intent))
+        throw new Error('LP_ATOMIC_INDEPENDENT_INTENT_MISMATCH');
+    if (canonicalJson(sequence.calls) !== canonicalJson(plan.calls) || canonicalJson(sequence.recoveryCalls) !== canonicalJson(plan.recoveryCalls) || canonicalJson(deployment) !== canonicalJson(plan.guardDeployment))
+        throw new Error('LP_ATOMIC_CALL_OR_DEPLOYMENT_MISMATCH');
+    const { planCommitment, ...body } = plan;
+    if (planCommitment !== commitment(body))
+        throw new Error('LP_ATOMIC_PLAN_COMMITMENT_MISMATCH');
+    if (BigInt(plan.preparedBlock.number) > BigInt(evidence.blockNumber) || (plan.preparedBlock.number === evidence.blockNumber && plan.preparedBlock.hash !== evidence.blockHash))
+        throw new Error('LP_ATOMIC_PREPARATION_BLOCK_MISMATCH');
+    return { plan, evidence };
+}
+/** A frozen policy is an independently reviewed HOST configuration. It is not
+ * wallet authority and must never be accepted alongside an external request. */
+export function createLpV3AtomicPlanner(guardDeployments) {
+    const policy = reviewedGuardPolicy(guardDeployments);
+    const nowOf = (options) => (options.now ?? (() => Math.floor(Date.now() / 1000)))();
+    return Object.freeze({
+        policy,
+        prepare(input, chainEvidence, options = {}) {
+            const intent = lpV3AtomicIntentSchema.parse(input), evidence = lpV3AtomicChainEvidenceSchema.parse(chainEvidence), now = nowOf(options);
+            const deployment = check(intent, evidence, policy, now), sequence = derive(intent, evidence, deployment, now);
+            const body = { schemaVersion: 2, kind: 'lp-v3-atomic', intent, signingSupport: 'HOST_GATES_REQUIRED', intentCommitment: commitment(intent), ...sequence, guardDeployment: deployment, preparedBlock: { number: evidence.blockNumber, hash: evidence.blockHash } };
+            return deepFreeze({ ...body, planCommitment: commitment(body) });
+        },
+        verify(input, independentIntent, freshEvidence, options = {}) {
+            const now = nowOf(options), { plan, evidence } = validate(input, independentIntent, freshEvidence, policy, now);
+            const result = deepFreeze({ purpose: 'execute', plan, evidence, verifiedAt: now });
+            verifiedPolicies.set(result, commitment(policy));
+            return result;
+        },
+        /** Recovery-only reconstruction from the protected journal's ORIGINAL baseline.
+         * The host must independently reread that historical block's canonical mapping.
+         * This separate brand cannot authorize calls, approvals or a new operation.
+         */
+        verifyForSettlement(input, journalIntent, historicalBaseline, canonicalReadback, options = {}) {
+            const proof = baselineReadbackSchema.parse(canonicalReadback), now = nowOf(options);
+            if (!Number.isSafeInteger(now) || now <= 0 || proof.canonicalCheckedAt > now || now - proof.canonicalCheckedAt > 30 || proof.originalVerifiedAt > proof.canonicalCheckedAt)
+                throw new Error('LP_ATOMIC_STALE_BASELINE_READBACK');
+            const { plan, evidence } = validate(input, journalIntent, historicalBaseline, policy, proof.originalVerifiedAt);
+            if (proof.operationId !== plan.intent.operationId || proof.planCommitment !== plan.planCommitment || proof.blockNumber !== evidence.blockNumber || proof.blockHash !== evidence.blockHash)
+                throw new Error('LP_ATOMIC_JOURNAL_BASELINE_MISMATCH');
+            const result = deepFreeze({ purpose: 'settle-only', plan, evidence, verifiedAt: proof.originalVerifiedAt });
+            settlementPolicies.set(result, commitment(policy));
+            return result;
+        },
+    });
+}
+//# sourceMappingURL=lp-v3-atomic-plan.js.map

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

@@ -0,0 +1,312 @@
+import { z } from 'zod';
+import type { LpV3AtomicReadClient } from './lp-v3-atomic-evidence.js';
+import type { LpV3AtomicSettlementEvidence, LpV3AtomicSettlementResult } from './lp-v3-atomic-settlement.js';
+/** Mandatory immutable HOST policy. This is not a caller assertion of finality. */
+export declare const lpV3FinalityPolicySchema: 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>;
+export type LpV3FinalityPolicy = z.infer<typeof lpV3FinalityPolicySchema>;
+export declare const lpV3JournalRequestSchema: z.ZodObject<{
+    userId: z.ZodString;
+    address: z.ZodString;
+    network: z.ZodLiteral<"base">;
+    transaction: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export declare const lpV3JournalTransactionSchema: z.ZodObject<{
+    callIndex: z.ZodNumber;
+    transactionHash: z.ZodString;
+    nonce: z.ZodString;
+    request: z.ZodObject<{
+        userId: z.ZodString;
+        address: z.ZodString;
+        network: z.ZodLiteral<"base">;
+        transaction: z.ZodString;
+        idempotencyKey: z.ZodString;
+    }, z.core.$strict>;
+    requestDigest: z.ZodString;
+    state: z.ZodEnum<{
+        confirmed: "confirmed";
+        submitted: "submitted";
+        mined: "mined";
+    }>;
+}, z.core.$strict>;
+export type LpV3JournalTransaction = z.infer<typeof lpV3JournalTransactionSchema>;
+export declare const lpV3SettlementReadInputSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    plan: 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>;
+    journal: z.ZodObject<{
+        userId: z.ZodString;
+        operationId: z.ZodString;
+        planCommitment: z.ZodString;
+        independentIntent: 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">;
+        baseline: 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>;
+        originalVerifiedAt: z.ZodNumber;
+        transactions: z.ZodArray<z.ZodObject<{
+            callIndex: z.ZodNumber;
+            transactionHash: z.ZodString;
+            nonce: z.ZodString;
+            request: z.ZodObject<{
+                userId: z.ZodString;
+                address: z.ZodString;
+                network: z.ZodLiteral<"base">;
+                transaction: z.ZodString;
+                idempotencyKey: z.ZodString;
+            }, z.core.$strict>;
+            requestDigest: z.ZodString;
+            state: z.ZodEnum<{
+                confirmed: "confirmed";
+                submitted: "submitted";
+                mined: "mined";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type LpV3SettlementReadInput = z.infer<typeof lpV3SettlementReadInputSchema>;
+export interface LpV3SettlementReadClient {
+    request(request: Omit<Parameters<LpV3AtomicReadClient['request']>[0], 'method'> & {
+        method: Parameters<LpV3AtomicReadClient['request']>[0]['method'] | 'eth_getTransactionByHash' | 'eth_getTransactionReceipt';
+    }): Promise<unknown>;
+}
+export declare const LP_V3_READ_HOLD_REASONS: readonly ["INVALID_INPUT", "INVALID_CLOCK", "JOURNAL_MISMATCH", "RPC_UNAVAILABLE", "WRONG_CHAIN", "FINALITY_UNAVAILABLE", "FINALITY_STALE", "NOT_FINALIZED", "TRANSACTION_UNAVAILABLE", "TRANSACTION_MISMATCH", "RECEIPT_UNAVAILABLE", "TRANSACTION_REVERTED", "RECEIPT_MISMATCH", "BLOCK_REORG", "HISTORY_UNAVAILABLE", "BASELINE_MISMATCH", "SETTLEMENT_UNPROVEN", "READ_STALE"];
+export type LpV3ReadHoldReason = typeof LP_V3_READ_HOLD_REASONS[number];
+export interface LpV3ReadFinalityEvidence {
+    policyCommitment: string;
+    observedAt: number;
+    latest: {
+        number: string;
+        hash: string;
+        timestamp: number;
+    };
+    finalized: {
+        number: string;
+        hash: string;
+        timestamp: number;
+    };
+    minimumObservedFinalizedConfirmations: string;
+}
+interface NoAuthority {
+    executionAuthorized: false;
+    claimReleased: false;
+    retainClaim: true;
+    retrySafe: false;
+}
+export type LpV3SettlementReadResult = (NoAuthority & {
+    status: 'HELD';
+    settlement: 'UNKNOWN';
+    reason: LpV3ReadHoldReason;
+    operationId: string | null;
+    planCommitment: string | null;
+}) | (NoAuthority & {
+    status: 'SETTLEMENT_VERIFIED';
+    operationId: string;
+    planCommitment: string;
+    journalCommitment: string;
+    evidence: LpV3AtomicSettlementEvidence;
+    finality: LpV3ReadFinalityEvidence;
+    result: LpV3AtomicSettlementResult;
+});
+export {};

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { lpHash, lpUint } from './lp-v3-contract.js';
+import { lpV3AtomicPlanSchema, lpV3AtomicIntentSchema, lpV3AtomicChainEvidenceSchema } from './lp-v3-atomic-contract.js';
+/** Mandatory immutable HOST policy. This is not a caller assertion of finality. */
+export const lpV3FinalityPolicySchema = z.object({
+    schemaVersion: z.literal(1), id: z.literal('base-finalized-lp-v1'), chainId: z.literal(8453),
+    blockTag: z.literal('finalized'), reviewReference: z.string().min(16).max(200),
+    minFinalizedConfirmations: z.number().int().min(1).max(10_000),
+    maxHeadAgeSeconds: z.number().int().min(1).max(60),
+    maxFinalizedLagSeconds: z.number().int().min(1).max(3600),
+    maxReadDurationSeconds: z.number().int().min(1).max(30),
+}).strict();
+const userId = z.string().regex(/^[a-zA-Z0-9-]{1,100}$/);
+// Exact CDP EOA request projection. Preserve string case and field order for the
+// existing native-account SHA-256(JSON.stringify(request)) journal digest.
+export const lpV3JournalRequestSchema = z.object({
+    userId, address: z.string().regex(/^0x[0-9a-fA-F]{40}$/), network: z.literal('base'),
+    transaction: z.string().regex(/^0x(?:[0-9a-fA-F]{2})+$/), idempotencyKey: z.string().uuid(),
+}).strict();
+export const lpV3JournalTransactionSchema = z.object({
+    callIndex: z.number().int().min(0).max(4), transactionHash: lpHash, nonce: lpUint(64),
+    request: lpV3JournalRequestSchema, requestDigest: z.string().regex(/^[0-9a-f]{64}$/),
+    state: z.enum(['submitted', 'mined', 'confirmed']),
+}).strict();
+export const lpV3SettlementReadInputSchema = z.object({
+    schemaVersion: z.literal(1), plan: lpV3AtomicPlanSchema,
+    // Independently loaded from the protected journal, never external request fields.
+    journal: z.object({
+        userId, operationId: z.string().regex(/^[a-zA-Z0-9_-]{16,96}$/), planCommitment: lpHash,
+        independentIntent: lpV3AtomicIntentSchema, baseline: lpV3AtomicChainEvidenceSchema,
+        originalVerifiedAt: z.number().int().positive().safe(),
+        transactions: z.array(lpV3JournalTransactionSchema).min(2).max(5),
+    }).strict(),
+}).strict();
+export const LP_V3_READ_HOLD_REASONS = [
+    'INVALID_INPUT', 'INVALID_CLOCK', 'JOURNAL_MISMATCH', 'RPC_UNAVAILABLE', 'WRONG_CHAIN',
+    'FINALITY_UNAVAILABLE', 'FINALITY_STALE', 'NOT_FINALIZED', 'TRANSACTION_UNAVAILABLE',
+    'TRANSACTION_MISMATCH', 'RECEIPT_UNAVAILABLE', 'TRANSACTION_REVERTED', 'RECEIPT_MISMATCH',
+    'BLOCK_REORG', 'HISTORY_UNAVAILABLE', 'BASELINE_MISMATCH', 'SETTLEMENT_UNPROVEN', 'READ_STALE',
+];
+//# sourceMappingURL=lp-v3-atomic-read-contract.js.map

package/dist/vendor/lp-v3/lp-v3-atomic-read-index.d.ts

@@ -0,0 +1,3 @@
+export { createLpV3AtomicSettlementReader, type LpV3SettlementReaderOptions } from './lp-v3-atomic-read.js';
+export { lpV3FinalityPolicySchema, lpV3SettlementReadInputSchema, lpV3JournalTransactionSchema, lpV3JournalRequestSchema, LP_V3_READ_HOLD_REASONS } from './lp-v3-atomic-read-contract.js';
+export type { LpV3FinalityPolicy, LpV3JournalTransaction, LpV3SettlementReadInput, LpV3SettlementReadClient, LpV3SettlementReadResult, LpV3ReadFinalityEvidence, LpV3ReadHoldReason } from './lp-v3-atomic-read-contract.js';

package/dist/vendor/lp-v3/lp-v3-atomic-read-index.js

@@ -0,0 +1,3 @@
+export { createLpV3AtomicSettlementReader } from './lp-v3-atomic-read.js';
+export { lpV3FinalityPolicySchema, lpV3SettlementReadInputSchema, lpV3JournalTransactionSchema, lpV3JournalRequestSchema, LP_V3_READ_HOLD_REASONS } from './lp-v3-atomic-read-contract.js';
+//# sourceMappingURL=lp-v3-atomic-read-index.js.map