otto-intel-mcp 0.1.2 → 0.1.4

package/dist/lp-userop-authority.js

@@ -0,0 +1,211 @@
+/** One manually reviewed LP collection. No signer, durable consent, transport or parallel journal. */
+import { getAddress } from 'viem';
+import { freezeHybridValue, hybridYieldCommitment } from './hybrid-yield-markets.js';
+import { policyRulesDigest } from './execution-policy-compatibility.js';
+import { SPONSORED_ACCOUNT_ACTIVATIONS, SPONSORED_ACTIVATION_SCHEMA, SPONSORED_NATIVE_USEROP_PROFILE_SCHEMA, sponsoredChainTerms, sponsoredDigest } from './execution-sponsored-definition.js';
+import { assertSponsoredAccountProfile, SponsoredAccountProfileError } from './execution-sponsored-account-profile.js';
+import { NATIVE_YIELD_ACCOUNT_ACTIVATIONS } from './native-yield-account-definition.js';
+import { resolveNativeYieldAccountActivation } from './native-yield-account-policy.js';
+import { assertNativeLpCollectPolicyRelation, lpUserOpActivationCommitment } from './account-userop-policy-relation.js';
+import { LP_USEROP_ACTIVATIONS, LP_USEROP_ACTIVATION_SCHEMA, LP_USEROP_INPUT_SCHEMA, LP_USEROP_REVIEW_RECORD_SCHEMA, LP_USEROP_TERMS_SCHEMA, LP_USEROP_RULESET, LP_USEROP_REVIEW_TTL_MS, LP_USEROP_ZERO_ADDRESS } from './lp-userop-definition.js';
+import { commitment as protocolCommitment, LP_V3_BASE } from './vendor/lp-v3/lp-v3-contract.js';
+export class LpUserOpAuthorityRefusal extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'LpUserOpAuthorityRefusal';
+    }
+}
+function ensure(value, code) { if (!value)
+    throw new LpUserOpAuthorityRefusal(code); }
+const equal = (left, right) => hybridYieldCommitment(left) === hybridYieldCommitment(right);
+const brand = Symbol('lp-userop-authority');
+const sourceIdentity = ({ nativeActivation, sponsorActivation, lpActivation, chainTerms, profile }) => ({ nativeActivation, sponsorActivation, lpActivation, chainTerms, profile });
+export class LpUserOpAuthorityIssuer {
+    sponsor;
+    issued = new WeakMap();
+    capLocked = new WeakSet();
+    nativeActivations;
+    sponsorActivations;
+    lpActivations;
+    constructor(sponsor, 
+    /** Internal fixtures only; the production constructor reads three empty reviewed source arrays. */
+    fixtures) {
+        this.sponsor = sponsor;
+        this.nativeActivations = fixtures?.nativeActivations ?? NATIVE_YIELD_ACCOUNT_ACTIVATIONS;
+        this.sponsorActivations = fixtures?.sponsoredActivations ?? SPONSORED_ACCOUNT_ACTIVATIONS;
+        this.lpActivations = fixtures?.lpActivations ?? LP_USEROP_ACTIVATIONS;
+    }
+    now() {
+        const now = this.sponsor.now();
+        ensure(Number.isSafeInteger(now) && now > 0, 'LP_USEROP_CLOCK');
+        return now;
+    }
+    sources(input) {
+        // Refuse inactive production before touching the runtime, SDK, caps or public RPC.
+        ensure(this.nativeActivations.length === 1 && this.sponsorActivations.length === 1 && this.lpActivations.length === 1, 'LP_USEROP_SOURCE_ACTIVATIONS_REQUIRED');
+        const nativeActivation = resolveNativeYieldAccountActivation(8453, this.nativeActivations);
+        const sponsorActivation = SPONSORED_ACTIVATION_SCHEMA.parse(this.sponsorActivations[0]);
+        const lpActivation = LP_USEROP_ACTIVATION_SCHEMA.parse(this.lpActivations[0]);
+        ensure(sponsorActivation.mode === 'enabled' && lpActivation.mode === 'enabled' &&
+            sponsorActivation.projectId === this.sponsor.projectId &&
+            sponsorActivation.approvedAtMs <= this.now() && sponsorActivation.expiresAtMs > this.now() &&
+            lpActivation.approvedAtMs <= this.now() && lpActivation.expiresAtMs > this.now(), 'LP_USEROP_ACTIVATION_UNAVAILABLE');
+        assertNativeLpCollectPolicyRelation(nativeActivation, sponsorActivation, lpActivation);
+        const chainTerms = sponsoredChainTerms(sponsorActivation, 8453);
+        const profile = SPONSORED_NATIVE_USEROP_PROFILE_SCHEMA.parse(chainTerms.nativeYieldUserOpProfile);
+        ensure(input.account === input.recipient && input.guardDeploymentId === lpActivation.guardDeployment.id &&
+            input.amountMax.every((amount, i) => BigInt(amount) <= BigInt(lpActivation.maximumCollectAtomic[i])) &&
+            input.amountMax.some(amount => amount !== '0') &&
+            input.amountMin.every((amount, i) => BigInt(amount) <= BigInt(input.amountMax[i])) &&
+            Number.isSafeInteger(input.deadline * 1000) && input.deadline * 1000 > this.now() &&
+            input.deadline * 1000 - this.now() <= lpActivation.maximumDeadlineSeconds * 1000, 'LP_USEROP_INTENT_OUTSIDE_REVIEWED_SCOPE');
+        return freezeHybridValue({ nativeActivation, sponsorActivation, lpActivation, chainTerms, profile });
+    }
+    window(input, facts, prior) {
+        const reviewCreatedAtMs = prior?.reviewCreatedAtMs ?? this.now();
+        const reviewExpiresAtMs = Math.min(reviewCreatedAtMs + LP_USEROP_REVIEW_TTL_MS, facts.lpActivation.expiresAtMs, facts.sponsorActivation.expiresAtMs, Date.parse(facts.sponsorAuthority.grantExpiresAt), input.deadline * 1000);
+        ensure(reviewCreatedAtMs <= this.now() && this.now() < reviewExpiresAtMs &&
+            (!prior || prior.reviewExpiresAtMs === reviewExpiresAtMs), 'LP_USEROP_REVIEW_EXPIRED');
+        return { reviewCreatedAtMs, reviewExpiresAtMs };
+    }
+    derivedTerms(input, facts, window) {
+        const { sponsorActivation: activation, lpActivation, chainTerms: chain, profile, sponsorAuthority } = facts;
+        const intentCommitment = protocolCommitment(input);
+        return freezeHybridValue(LP_USEROP_TERMS_SCHEMA.parse({
+            version: 1, ruleset: LP_USEROP_RULESET, userId: sponsorAuthority.userId, account: sponsorAuthority.account, chainId: 8453,
+            authorityDigest: sponsoredDigest({ domain: 'lp-userop-current-operation-authority-v1', sponsorAuthority,
+                lpActivationCommitment: lpUserOpActivationCommitment(lpActivation), intentCommitment, ...window }),
+            lpActivationCommitment: lpUserOpActivationCommitment(lpActivation), sponsoredActivationId: activation.id,
+            sponsoredActivationDigest: sponsoredDigest(activation), projectId: activation.projectId,
+            policyId: activation.policyId, policyRulesDigest: activation.policyRulesDigest,
+            providerEnforcementEvidenceDigest: activation.providerEnforcementEvidenceDigest,
+            providerEndpoint: 'cdp-end-user-smart-account-send-v1', guardDeployment: lpActivation.guardDeployment,
+            finalityPolicy: lpActivation.finalityPolicy,
+            delegate: chain.delegate, delegateCodeHash: chain.delegateCodeHash,
+            implementation: profile.implementation, implementationCodeHash: profile.implementationCodeHash,
+            delegateBatchAbi: profile.delegateBatchAbi, delegateBatchReviewDigest: profile.delegateBatchReviewDigest,
+            entryPoint: chain.entryPoint, entryPointCodeHash: chain.entryPointCodeHash,
+            entryPointVersion: profile.entryPointVersion, ownerProfile: { kind: 'sole-eoa-owner', nextOwnerIndex: '1',
+                ownerCount: '1', ownerAtIndex0: '0x' + '0'.repeat(24) + sponsorAuthority.account.slice(2).toLowerCase(),
+                spendPermissionsEnabled: false },
+            paymaster: chain.paymaster, paymasterCodeHash: chain.paymasterCodeHash,
+            sponsorshipPolicyId: chain.sponsorshipPolicyId, maxGasCostWei: chain.maxGasCostWei,
+            maxUserGasCostWei: chain.maxUserGasCostWei, maxTotalGasCostWei: chain.maxTotalGasCostWei,
+            maximumCollectAtomic: lpActivation.maximumCollectAtomic, intentCommitment, ...window,
+            initialNftApproval: LP_USEROP_ZERO_ADDRESS, finalNftApproval: LP_USEROP_ZERO_ADDRESS,
+            execution: 'atomic-nft-approve-guarded-collect', principalDebitAuthorized: false,
+        }));
+    }
+    async facts(accessToken, input) {
+        const source = this.sources(input), account = getAddress(input.account);
+        // Both possible collection assets are source reviewed. These share a grant fingerprint;
+        // neither the legacy perSwapCapUsd nor a quote is represented as an LP notional limit.
+        const first = await this.sponsor.authority(accessToken, account, 8453, source.sponsorActivation, getAddress(LP_V3_BASE.token0), 'lp-collect-userop');
+        const second = await this.sponsor.authority(accessToken, account, 8453, source.sponsorActivation, getAddress(LP_V3_BASE.token1), 'lp-collect-userop');
+        ensure(equal(first, second), 'LP_USEROP_CURRENT_AUTHORITY_CHANGED');
+        const facts = { ...source, sponsorAuthority: second };
+        const proofTerms = this.derivedTerms(input, facts, this.window(input, facts));
+        const client = this.sponsor.client(8453), block = await client.getBlock({ blockTag: 'latest' });
+        const timestampMs = Number(block.timestamp) * 1000;
+        ensure(block.number !== null && block.hash && Number.isSafeInteger(timestampMs) && timestampMs > 0 &&
+            timestampMs <= this.now() + 5000 && this.now() - timestampMs <= 60_000, 'LP_USEROP_ACCOUNT_ANCHOR');
+        try {
+            await assertSponsoredAccountProfile(client, proofTerms, block.number, block.hash, [
+                { address: getAddress(source.lpActivation.guardDeployment.address), codeHash: source.lpActivation.guardDeployment.runtimeCodeHash },
+                { address: getAddress(LP_V3_BASE.manager), codeHash: LP_V3_BASE.managerCodeHash },
+                { address: getAddress(LP_V3_BASE.token0), codeHash: LP_V3_BASE.token0CodeHash },
+                { address: getAddress(LP_V3_BASE.token1), codeHash: LP_V3_BASE.token1CodeHash },
+            ]);
+        }
+        catch (error) {
+            if (error instanceof SponsoredAccountProfileError)
+                throw new LpUserOpAuthorityRefusal('LP_USEROP_ACCOUNT_' + error.reason);
+            throw error;
+        }
+        const [who, grant, policyReply] = await Promise.all([
+            this.sponsor.identity(accessToken, account),
+            this.sponsor.cdp.endUser.getDelegationForEndUserAccount({ userId: second.userId, address: account }),
+            this.sponsor.cdp.policies.listPolicies({ scope: 'project' }),
+        ]);
+        const smart = (who.current.evmSmartAccountObjects ?? []).filter(value => getAddress(value.address) === account);
+        const policies = (policyReply.policies ?? []).filter(value => value.scope === 'project');
+        ensure(who.userId === second.userId && smart.length === 1 && smart[0].ownerAddresses.length === 1 &&
+            getAddress(smart[0].ownerAddresses[0]) === account &&
+            Date.parse(grant.expiresAt) === Date.parse(second.grantExpiresAt) && Date.parse(grant.expiresAt) > this.now() &&
+            policies.length === 1 && policies[0].id === source.sponsorActivation.policyId &&
+            policies[0].description === source.sponsorActivation.policyName &&
+            policyRulesDigest(policies[0].rules) === source.sponsorActivation.policyRulesDigest, 'LP_USEROP_CURRENT_AUTHORITY_CHANGED');
+        await this.sponsor.assertCurrentCap(second);
+        ensure(equal(sourceIdentity(this.sources(input)), sourceIdentity(source)), 'LP_USEROP_SOURCE_CHANGED');
+        return freezeHybridValue(facts);
+    }
+    async issue(accessToken, rawInput, previous) {
+        const input = freezeHybridValue(LP_USEROP_INPUT_SCHEMA.parse(rawInput));
+        const facts = await this.facts(accessToken, input);
+        const terms = this.derivedTerms(input, facts, this.window(input, facts, previous?.terms));
+        const review = freezeHybridValue(LP_USEROP_REVIEW_RECORD_SCHEMA.parse({ input, terms }));
+        ensure(!previous || equal(review, previous), 'LP_USEROP_REVIEW_AUTHORITY_CHANGED');
+        const token = Object.freeze({ [brand]: true });
+        this.issued.set(token, { facts, review });
+        this.assertCurrent(token);
+        return token;
+    }
+    mint(accessToken, rawInput) { return this.issue(accessToken, rawInput); }
+    read(authority) {
+        const issued = authority && this.issued.get(authority);
+        ensure(issued, 'LP_USEROP_OPAQUE_AUTHORITY_REQUIRED');
+        return issued;
+    }
+    async refresh(accessToken, authority) {
+        const previous = this.read(authority).review;
+        return this.issue(accessToken, previous.input, previous);
+    }
+    /** Only immutable trusted journal context may enter here; never caller-supplied terms. */
+    async restoreFromTrustedReview(accessToken, rawReview) {
+        const review = LP_USEROP_REVIEW_RECORD_SCHEMA.parse(rawReview);
+        return this.issue(accessToken, review.input, review);
+    }
+    assertScope(authority) {
+        const { facts, review } = this.read(authority);
+        this.window(review.input, facts, review.terms);
+        ensure(equal(sourceIdentity(this.sources(review.input)), sourceIdentity(facts)), 'LP_USEROP_SOURCE_CHANGED');
+    }
+    /** Synchronous source/time and Stop check, including inside the caller's shared-journal stamp. */
+    assertCurrent(authority) { this.withCurrentCap(authority, () => undefined); }
+    /** The existing cap writer lock orders Stop against the synchronous provider POST invocation. */
+    withCurrentCap(authority, start) {
+        this.assertScope(authority);
+        // A provider-start callback may inspect this same authority while its lock is already held.
+        if (this.capLocked.has(authority))
+            return start();
+        return this.sponsor.withCurrentCap(this.read(authority).facts.sponsorAuthority, () => {
+            this.assertScope(authority);
+            this.capLocked.add(authority);
+            try {
+                return start();
+            }
+            finally {
+                this.capLocked.delete(authority);
+            }
+        });
+    }
+    terms(authority) {
+        this.assertCurrent(authority);
+        return this.read(authority).review.terms;
+    }
+    reviewRecord(authority) {
+        this.assertCurrent(authority);
+        return this.read(authority).review;
+    }
+    sponsorship(authority) {
+        this.assertCurrent(authority);
+        return this.read(authority).facts.sponsorAuthority;
+    }
+    activation(authority) {
+        this.assertCurrent(authority);
+        return this.read(authority).facts.sponsorActivation;
+    }
+}
+//# sourceMappingURL=lp-userop-authority.js.map

package/dist/lp-userop-definition.d.ts

@@ -0,0 +1,233 @@
+import { z } from 'zod';
+export declare const LP_USEROP_RULESET: "lp-guarded-collect-userop-v1";
+export declare const LP_USEROP_REVIEW_TTL_MS: number;
+export declare const LP_USEROP_CONFIRMATION: "I reviewed this position collection and sponsored atomic batch";
+export declare const LP_USEROP_ACCOUNT_GAS_CONFIRMATION: "I reviewed this position collection and account-paid atomic batch";
+export declare const LP_USEROP_ZERO_ADDRESS: "0x0000000000000000000000000000000000000000";
+/** These are host collection ceilings. A swap cap is not an LP notional limit. */
+export declare const LP_USEROP_ACTIVATION_SCHEMA: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    ruleset: z.ZodLiteral<"lp-guarded-collect-userop-v1">;
+    id: z.ZodString;
+    mode: z.ZodEnum<{
+        enabled: "enabled";
+        "recovery-only": "recovery-only";
+    }>;
+    approvedAtMs: z.ZodNumber;
+    expiresAtMs: z.ZodNumber;
+    nativeActivationCommitment: 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>;
+    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>;
+    capabilities: z.ZodTuple<[z.ZodLiteral<"guarded-collect">], null>;
+    maximumCollectAtomic: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    maximumDeadlineSeconds: z.ZodNumber;
+    reviewEvidenceDigest: z.ZodString;
+}, z.core.$strict>;
+export type LpUserOpActivation = z.infer<typeof LP_USEROP_ACTIVATION_SCHEMA>;
+/** No environment switch, request field or imported plan can populate this source authority. */
+export declare const LP_USEROP_ACTIVATIONS: readonly LpUserOpActivation[];
+export declare const LP_USEROP_TERMS_SCHEMA: 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>;
+export type LpUserOpTerms = z.infer<typeof LP_USEROP_TERMS_SCHEMA>;
+/** The protocol owner defines this v3 collect intent; older EOA intents remain separate. */
+export declare const LP_USEROP_INPUT_SCHEMA: 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>;
+export type LpUserOpInput = z.infer<typeof LP_USEROP_INPUT_SCHEMA>;
+export declare const LP_USEROP_REVIEW_RECORD_SCHEMA: z.ZodObject<{
+    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>;
+    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>;
+}, z.core.$strict>;
+export type LpUserOpReviewRecord = z.infer<typeof LP_USEROP_REVIEW_RECORD_SCHEMA>;

package/dist/lp-userop-definition.js

@@ -0,0 +1,85 @@
+/** Manual guarded collection for a separately upgraded same-address account. */
+import { getAddress } from 'viem';
+import { z } from 'zod';
+import { lpV3GuardDeploymentSchema } from './vendor/lp-v3/lp-v3-atomic-contract.js';
+import { lpV3FinalityPolicySchema } from './vendor/lp-v3/lp-v3-atomic-read-contract.js';
+import { lpV3CollectProtocolIntentSchema } from './vendor/lp-v3/lp-v3-collect-protocol-contract.js';
+import { SPONSORED_ACCOUNT_PROXY, SPONSORED_ACCOUNT_IMPLEMENTATION, SPONSORED_ACCOUNT_ENTRY_POINT } from './execution-sponsored-account-profile.js';
+export const LP_USEROP_RULESET = 'lp-guarded-collect-userop-v1';
+export const LP_USEROP_REVIEW_TTL_MS = 5 * 60_000;
+export const LP_USEROP_CONFIRMATION = 'I reviewed this position collection and sponsored atomic batch';
+export const LP_USEROP_ACCOUNT_GAS_CONFIRMATION = 'I reviewed this position collection and account-paid atomic batch';
+export const LP_USEROP_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const address = z.string().regex(/^0x[0-9a-fA-F]{40}$/).transform((value, context) => {
+    try {
+        return getAddress(value);
+    }
+    catch {
+        context.addIssue({ code: 'custom', message: 'Invalid account address' });
+        return z.NEVER;
+    }
+});
+const hash = z.string().regex(/^0x[0-9a-fA-F]{64}$/).refine(value => !/^0x0{64}$/i.test(value));
+const digest = z.string().regex(/^[0-9a-f]{64}$/).refine(value => !/^0+$/.test(value));
+const commitment = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const time = z.number().int().positive().safe();
+const uint128 = z.string().regex(/^(0|[1-9][0-9]{0,38})$/)
+    .refine(value => /^(0|[1-9][0-9]{0,38})$/.test(value) && BigInt(value) < (1n << 128n));
+const positive = z.string().regex(/^[1-9][0-9]{0,77}$/)
+    .refine(value => /^[1-9][0-9]{0,77}$/.test(value) && BigInt(value) < (1n << 256n));
+/** These are host collection ceilings. A swap cap is not an LP notional limit. */
+export const LP_USEROP_ACTIVATION_SCHEMA = z.object({
+    version: z.literal(1), ruleset: z.literal(LP_USEROP_RULESET),
+    id: z.string().regex(/^[a-zA-Z0-9_-]{8,100}$/), mode: z.enum(['enabled', 'recovery-only']),
+    approvedAtMs: time, expiresAtMs: time,
+    nativeActivationCommitment: commitment,
+    guardDeployment: lpV3GuardDeploymentSchema,
+    finalityPolicy: lpV3FinalityPolicySchema,
+    capabilities: z.tuple([z.literal('guarded-collect')]),
+    maximumCollectAtomic: z.tuple([uint128, uint128]),
+    maximumDeadlineSeconds: z.number().int().positive().max(300),
+    reviewEvidenceDigest: digest,
+}).strict().refine(value => value.expiresAtMs > value.approvedAtMs &&
+    value.expiresAtMs - value.approvedAtMs <= 180 * 24 * 60 * 60_000 &&
+    value.maximumCollectAtomic.some(amount => amount !== '0'), 'A current bounded reviewed collection scope is required');
+/** No environment switch, request field or imported plan can populate this source authority. */
+export const LP_USEROP_ACTIVATIONS = Object.freeze([]);
+export const LP_USEROP_TERMS_SCHEMA = z.object({
+    version: z.literal(1), ruleset: z.literal(LP_USEROP_RULESET),
+    userId: z.string().regex(/^[a-zA-Z0-9-]{1,100}$/), account: address, chainId: z.literal(8453),
+    authorityDigest: digest, lpActivationCommitment: commitment,
+    sponsoredActivationId: z.string().regex(/^[a-zA-Z0-9_-]{8,100}$/), sponsoredActivationDigest: digest,
+    projectId: z.string().uuid(), policyId: z.string().min(1).max(200),
+    policyRulesDigest: digest, providerEnforcementEvidenceDigest: digest,
+    providerEndpoint: z.literal('cdp-end-user-smart-account-send-v1'),
+    guardDeployment: lpV3GuardDeploymentSchema,
+    finalityPolicy: lpV3FinalityPolicySchema,
+    delegate: address, delegateCodeHash: hash, implementation: address, implementationCodeHash: hash,
+    delegateBatchAbi: z.literal('coinbase-executeBatch-v1'), delegateBatchReviewDigest: digest,
+    entryPoint: address, entryPointCodeHash: hash, entryPointVersion: z.literal('0.6'),
+    ownerProfile: z.object({ kind: z.literal('sole-eoa-owner'), nextOwnerIndex: z.literal('1'), ownerCount: z.literal('1'),
+        ownerAtIndex0: z.string().regex(/^0x0{24}[0-9a-fA-F]{40}$/).transform(value => value.toLowerCase()),
+        spendPermissionsEnabled: z.literal(false),
+    }).strict(),
+    paymaster: address, paymasterCodeHash: hash,
+    sponsorshipPolicyId: z.string().regex(/^[a-zA-Z0-9_-]{1,128}$/),
+    maxGasCostWei: positive, maxUserGasCostWei: positive, maxTotalGasCostWei: positive,
+    maximumCollectAtomic: z.tuple([uint128, uint128]),
+    intentCommitment: hash,
+    reviewCreatedAtMs: time, reviewExpiresAtMs: time,
+    initialNftApproval: z.literal(LP_USEROP_ZERO_ADDRESS),
+    finalNftApproval: z.literal(LP_USEROP_ZERO_ADDRESS),
+    execution: z.literal('atomic-nft-approve-guarded-collect'),
+    principalDebitAuthorized: z.literal(false),
+}).strict().refine(value => value.delegate === SPONSORED_ACCOUNT_PROXY &&
+    value.implementation === SPONSORED_ACCOUNT_IMPLEMENTATION && value.entryPoint === SPONSORED_ACCOUNT_ENTRY_POINT &&
+    value.ownerProfile.ownerAtIndex0 === '0x' + '0'.repeat(24) + value.account.slice(2).toLowerCase() &&
+    value.reviewExpiresAtMs > value.reviewCreatedAtMs && value.reviewExpiresAtMs - value.reviewCreatedAtMs <= LP_USEROP_REVIEW_TTL_MS &&
+    BigInt(value.maxGasCostWei) <= BigInt(value.maxUserGasCostWei) && BigInt(value.maxUserGasCostWei) <= BigInt(value.maxTotalGasCostWei) &&
+    ![value.account, value.paymaster].some(target => target === LP_USEROP_ZERO_ADDRESS), 'LP terms require the reviewed same-address account family and fresh bounded operation review');
+/** The protocol owner defines this v3 collect intent; older EOA intents remain separate. */
+export const LP_USEROP_INPUT_SCHEMA = lpV3CollectProtocolIntentSchema;
+export const LP_USEROP_REVIEW_RECORD_SCHEMA = z.object({
+    input: LP_USEROP_INPUT_SCHEMA, terms: LP_USEROP_TERMS_SCHEMA,
+}).strict();
+//# sourceMappingURL=lp-userop-definition.js.map

package/dist/lp-userop-hosted.d.ts

@@ -0,0 +1,3 @@
+import { type DelegationServices } from './execution-delegation.js';
+import { type LpUserOpBinding } from './lp-userop-registration.js';
+export declare function createHostedLpUserOpBinding(env: NodeJS.ProcessEnv, delegation: DelegationServices): Promise<LpUserOpBinding>;

package/dist/lp-userop-hosted.js

@@ -0,0 +1,73 @@
+import { LP_USEROP_ACTIVATIONS } from './lp-userop-definition.js';
+import { NATIVE_YIELD_ACCOUNT_ACTIVATIONS } from './native-yield-account-definition.js';
+import { loadDelegationEnv } from './execution-delegation.js';
+import { resolveDelegationCapStorePath } from './execution-delegation-cap-store.js';
+import { SPONSORED_ACCOUNT_ACTIVATIONS, SPONSORED_ACTIVATION_SCHEMA } from './execution-sponsored-definition.js';
+import { createLpUserOpAccountService } from './lp-userop-index.js';
+import { unavailableLpUserOpBinding } from './lp-userop-registration.js';
+import { LP_USEROP_AVAILABILITY_RESULT } from './lp-userop-mcp-definition.js';
+const RPC_ENV = Object.freeze({
+    1: 'OTTO_SPONSORED_RPC_URL_1', 8453: 'BASE_RPC_URL', 42161: 'OTTO_SPONSORED_RPC_URL_42161',
+    10: 'OTTO_SPONSORED_RPC_URL_10', 137: 'OTTO_SPONSORED_RPC_URL_137',
+});
+function privateHttpsUrl(raw) {
+    if (!raw)
+        throw new Error('missing operator endpoint');
+    const url = new URL(raw);
+    if (url.protocol !== 'https:' || url.username || url.password || url.hash)
+        throw new Error('invalid operator endpoint');
+    return url.toString();
+}
+export async function createHostedLpUserOpBinding(env, delegation) {
+    // This is not an environment toggle. Adding endpoints cannot authorize a new financial rail.
+    if (SPONSORED_ACCOUNT_ACTIVATIONS.length !== 1 || LP_USEROP_ACTIVATIONS.length !== 1 || NATIVE_YIELD_ACCOUNT_ACTIVATIONS.length !== 1)
+        return unavailableLpUserOpBinding();
+    try {
+        const activation = SPONSORED_ACTIVATION_SCHEMA.parse(SPONSORED_ACCOUNT_ACTIVATIONS[0]);
+        const loaded = loadDelegationEnv(env);
+        if (!loaded || loaded.publicProjectId !== activation.projectId ||
+            delegation.publicProjectId !== activation.projectId)
+            return unavailableLpUserOpBinding('SPONSOR_ACTIVATION_UNAVAILABLE');
+        const operationStorePath = resolveDelegationCapStorePath(env);
+        if (!operationStorePath)
+            return unavailableLpUserOpBinding('SPONSOR_JOURNAL_UNAVAILABLE');
+        const providers = [];
+        const urls = new Map();
+        for (const terms of activation.chains) {
+            try {
+                providers.push({ chainId: terms.chainId, sponsorshipPolicyId: terms.sponsorshipPolicyId,
+                    paymasterUrl: privateHttpsUrl(env['OTTO_SPONSORED_PAYMASTER_URL_' + terms.chainId]) });
+            }
+            catch { /* Missing send configuration leaves recovery available. */ }
+            try {
+                urls.set(terms.chainId, privateHttpsUrl(env[RPC_ENV[terms.chainId]]));
+            }
+            catch { /* Read works without RPC; reconcile keeps the original evidence until this chain returns. */ }
+        }
+        const [{ CdpClient }, { createPublicClient, http }, chains] = await Promise.all([
+            import('@coinbase/cdp-sdk'), import('viem'), import('viem/chains'),
+        ]);
+        const definitions = { 1: chains.mainnet, 8453: chains.base, 42161: chains.arbitrum,
+            10: chains.optimism, 137: chains.polygon };
+        const clients = {};
+        for (const terms of activation.chains) {
+            if (terms.chainId === 8453 && delegation.pub)
+                clients[terms.chainId] = delegation.pub;
+            else if (urls.has(terms.chainId))
+                clients[terms.chainId] = createPublicClient({
+                    chain: definitions[terms.chainId], transport: http(urls.get(terms.chainId))
+                });
+        }
+        const service = await createLpUserOpAccountService({
+            cdp: new CdpClient(loaded.credentials), capStore: delegation.capStore,
+            projectId: activation.projectId, operationStorePath, client: clients[8453], providers: providers.filter(value => value.chainId === 8453), credentials: loaded.credentials,
+        });
+        return Object.freeze({ ...service, availability: async () => LP_USEROP_AVAILABILITY_RESULT.parse(await service.availability()) });
+    }
+    catch {
+        // Misconfigured sponsorship must not disable existing reads, Stop or recovery on other rails.
+        // Errors from providers may contain credentials; expose only a fixed status.
+        return unavailableLpUserOpBinding('SPONSOR_RUNTIME_UNAVAILABLE');
+    }
+}
+//# sourceMappingURL=lp-userop-hosted.js.map