otto-intel-mcp 0.1.2 → 0.1.4

package/dist/lp-userop.js

@@ -0,0 +1,343 @@
+/** Read-only LP preparation and atomic account-call verification. No sender or authority issuer. */
+import { encodeFunctionData, getAddress, parseAbi } from 'viem';
+import { z } from 'zod';
+import { hybridYieldCommitment, freezeHybridValue } from './hybrid-yield-markets.js';
+import { LP_USEROP_TERMS_SCHEMA } from './lp-userop-definition.js';
+import { assertSponsoredAccountProfile } from './execution-sponsored-account-profile.js';
+import { LP_V3_BASE, commitment as protocolCommitment } from './vendor/lp-v3/lp-v3-contract.js';
+import { LP_V3_ATOMIC_NPM_ABI, LP_V3_COLLECT_GUARD_ABI, reviewedGuardPolicy, } from './vendor/lp-v3/lp-v3-atomic-contract.js';
+import { lpV3FinalityPolicySchema, } from './vendor/lp-v3/lp-v3-atomic-read-contract.js';
+import { lpV3CollectProtocolIntentSchema, lpV3CollectProtocolPlanSchema, lpV3CollectProtocolObservationSchema, lpV3CollectProtocolCheckSchema, } from './vendor/lp-v3/lp-v3-collect-protocol-contract.js';
+import { createLpV3CollectProtocolLibrary, } from './vendor/lp-v3/lp-v3-collect-protocol-index.js';
+export const LP_USEROP_BATCH_ABI = parseAbi([
+    'function executeBatch((address target,uint256 value,bytes data)[] calls) payable',
+]);
+const time = z.number().int().positive().safe();
+export const LP_USEROP_VERIFICATION_EVIDENCE_SCHEMA = z
+    .object({
+    baseline: lpV3CollectProtocolObservationSchema,
+    check: lpV3CollectProtocolCheckSchema,
+    verifiedAtMs: time,
+})
+    .strict();
+export const LP_USEROP_SUBMIT_EVIDENCE_SCHEMA = LP_USEROP_VERIFICATION_EVIDENCE_SCHEMA;
+export const LP_USEROP_ENVELOPE_SCHEMA = z
+    .object({
+    version: z.literal(1),
+    kind: z.literal('lp-collect-userop'),
+    input: lpV3CollectProtocolIntentSchema,
+    plan: lpV3CollectProtocolPlanSchema,
+    baseline: lpV3CollectProtocolObservationSchema,
+    check: lpV3CollectProtocolCheckSchema,
+    terms: LP_USEROP_TERMS_SCHEMA,
+    finalityPolicy: lpV3FinalityPolicySchema,
+    preparedAtMs: time,
+    validUntilMs: time,
+    commitment: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+})
+    .strict();
+const verified = new WeakMap();
+const verifiedReadTime = new WeakMap();
+export class LpUserOpError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'LpUserOpError';
+    }
+}
+export function requireLpUserOp(value, code) {
+    if (!value)
+        throw new LpUserOpError(code);
+}
+const same = (a, b) => a.toLowerCase() === b.toLowerCase();
+export function lpUserOpNow(runtime) {
+    const now = (runtime.nowMs ?? Date.now)();
+    requireLpUserOp(Number.isSafeInteger(now) && now > 0, 'LP_USEROP_CLOCK');
+    return now;
+}
+/** Preserve the canonical library's EIP-1898 request objects through viem's custom RPC schema. */
+export function lpUserOpProtocolClient(client) {
+    return {
+        request: (request) => client.request({ method: request.method, params: request.params }),
+    };
+}
+export function lpUserOpProtocol(runtime, envelope) {
+    const policy = reviewedGuardPolicy(runtime.guardDeployments);
+    const finality = lpV3FinalityPolicySchema.parse(runtime.finalityPolicy);
+    if (envelope)
+        requireLpUserOp(hybridYieldCommitment(finality) === hybridYieldCommitment(envelope.finalityPolicy) &&
+            policy.some((guard) => protocolCommitment(guard) === protocolCommitment(envelope.terms.guardDeployment)), 'LP_USEROP_HOST_POLICY_CHANGED');
+    return createLpV3CollectProtocolLibrary({ guardDeployments: policy });
+}
+function startLpReadSpan(runtime) {
+    const monotonicMs = performance.now(), wallMs = lpUserOpNow(runtime);
+    requireLpUserOp(Number.isFinite(monotonicMs) && monotonicMs >= 0, 'LP_USEROP_CLOCK');
+    return { wallMs, monotonicMs };
+}
+function finishLpReadSpan(runtime, start) {
+    const wallMs = lpUserOpNow(runtime), monotonicMs = performance.now();
+    requireLpUserOp(wallMs >= start.wallMs && Number.isFinite(monotonicMs) && monotonicMs >= start.monotonicMs, 'LP_USEROP_CLOCK');
+    return {
+        wallMs,
+        monotonicMs,
+        effectiveMs: Math.max(wallMs, start.wallMs + monotonicMs - start.monotonicMs),
+    };
+}
+/** Bound every awaited read phase with both clocks; event-loop pauses cannot bypass the timer. */
+export async function boundedLpUserOpRead(runtime, work) {
+    const started = startLpReadSpan(runtime), duration = lpV3FinalityPolicySchema.parse(runtime.finalityPolicy).maxReadDurationSeconds * 1000;
+    let timer;
+    try {
+        const result = await Promise.race([
+            work(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new LpUserOpError('LP_USEROP_READ_TIMEOUT')), duration);
+            }),
+        ]);
+        const finished = finishLpReadSpan(runtime, started);
+        requireLpUserOp(finished.effectiveMs - started.wallMs <= duration, 'LP_USEROP_READ_STALE');
+        return result;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function recipe(input, terms) {
+    return [
+        {
+            step: 'nft-approve',
+            to: input.manager,
+            data: encodeFunctionData({
+                abi: LP_V3_ATOMIC_NPM_ABI,
+                functionName: 'approve',
+                args: [getAddress(terms.guardDeployment.address), BigInt(input.tokenId)],
+            }),
+        },
+        {
+            step: 'mutation',
+            to: terms.guardDeployment.address,
+            data: encodeFunctionData({
+                abi: LP_V3_COLLECT_GUARD_ABI,
+                functionName: 'collect',
+                args: [
+                    {
+                        owner: getAddress(input.account),
+                        pool: getAddress(input.pool),
+                        tokenId: BigInt(input.tokenId),
+                        tickLower: input.tickLower,
+                        tickUpper: input.tickUpper,
+                        amount0Max: BigInt(input.amountMax[0]),
+                        amount1Max: BigInt(input.amountMax[1]),
+                        amount0Min: BigInt(input.amountMin[0]),
+                        amount1Min: BigInt(input.amountMin[1]),
+                        deadline: BigInt(input.deadline),
+                    },
+                ],
+            }),
+        },
+    ];
+}
+/** Durable-record validation is not freshness, transport, execution or claim-release authority. */
+export function assertLpUserOpEnvelope(raw) {
+    const envelope = LP_USEROP_ENVELOPE_SCHEMA.parse(raw);
+    const { commitment, ...core } = envelope, { input, plan, terms, baseline, check } = envelope;
+    requireLpUserOp(hybridYieldCommitment(core) === commitment, 'LP_USEROP_TAMPERED');
+    requireLpUserOp(protocolCommitment(envelope.finalityPolicy) === protocolCommitment(terms.finalityPolicy), 'LP_USEROP_FINALITY_POLICY');
+    const { planCommitment, ...planCore } = plan, { checkCommitment, ...checkCore } = check;
+    requireLpUserOp(protocolCommitment(planCore) === planCommitment &&
+        protocolCommitment(checkCore) === checkCommitment, 'LP_USEROP_PROTOCOL_SEAL');
+    requireLpUserOp(protocolCommitment(input) === terms.intentCommitment &&
+        terms.intentCommitment === plan.intentCommitment &&
+        protocolCommitment(input) === protocolCommitment(plan.intent) &&
+        same(input.account, terms.account) &&
+        input.recipient === input.account &&
+        protocolCommitment(plan.guardDeployment) === protocolCommitment(terms.guardDeployment) &&
+        input.guardDeploymentId === terms.guardDeployment.id &&
+        input.chainId === terms.chainId &&
+        input.amountMax.every((amount, i) => BigInt(amount) <= BigInt(terms.maximumCollectAtomic[i])) &&
+        check.planCommitment === plan.planCommitment &&
+        check.intentCommitment === plan.intentCommitment &&
+        check.policyCommitment === plan.policyCommitment &&
+        check.baselineCommitment === protocolCommitment(baseline) &&
+        plan.preparedObservationCommitment === protocolCommitment(baseline) &&
+        plan.preparedBlock.number === baseline.blockNumber &&
+        plan.preparedBlock.hash === baseline.blockHash &&
+        check.checkedAt === Math.floor(envelope.preparedAtMs / 1000) &&
+        envelope.preparedAtMs >= terms.reviewCreatedAtMs &&
+        envelope.validUntilMs === Math.min(input.deadline * 1000, terms.reviewExpiresAtMs) &&
+        envelope.validUntilMs > envelope.preparedAtMs &&
+        baseline.position.approved === terms.initialNftApproval, 'LP_USEROP_BINDING');
+    const expected = recipe(input, terms);
+    requireLpUserOp(plan.calls.every((call, i) => call.step === expected[i].step &&
+        call.tokenIndex === null &&
+        call.chainId === terms.chainId &&
+        same(call.from, terms.account) &&
+        same(call.to, expected[i].to) &&
+        call.value === '0' &&
+        same(call.data, expected[i].data)), 'LP_USEROP_RECIPE');
+    // Replaying the record's policy proves integrity only. Fresh verification separately requires HOST policy.
+    const restored = createLpV3CollectProtocolLibrary({
+        guardDeployments: [terms.guardDeployment],
+    }).validatePrepared(plan, input, baseline, { now: () => check.checkedAt });
+    requireLpUserOp(protocolCommitment(restored) === protocolCommitment(check), 'LP_USEROP_PROTOCOL_CHECK');
+    return freezeHybridValue(envelope);
+}
+export async function assertLpUserOpAccountState(runtime, terms, blockNumber, blockHash) {
+    await assertSponsoredAccountProfile(runtime.client, LP_USEROP_TERMS_SCHEMA.parse(terms), blockNumber, blockHash, [
+        {
+            address: getAddress(terms.guardDeployment.address),
+            codeHash: terms.guardDeployment.runtimeCodeHash,
+        },
+        ...['factory', 'manager', 'token0', 'token1', 'usdcImplementation'].map((key) => ({
+            address: getAddress(LP_V3_BASE[key]),
+            codeHash: LP_V3_BASE[`${key}CodeHash`],
+        })),
+    ]);
+}
+function assertFresh(envelope, now) {
+    requireLpUserOp(now >= envelope.terms.reviewCreatedAtMs &&
+        now >= envelope.preparedAtMs &&
+        now < envelope.validUntilMs, 'LP_USEROP_EXPIRED');
+}
+export async function prepareLpUserOp(runtime, rawInput, independentTerms) {
+    return boundedLpUserOpRead(runtime, async () => {
+        const input = lpV3CollectProtocolIntentSchema.parse(rawInput), terms = LP_USEROP_TERMS_SCHEMA.parse(independentTerms);
+        const now = lpUserOpNow(runtime), finalityPolicy = lpV3FinalityPolicySchema.parse(runtime.finalityPolicy);
+        requireLpUserOp(now >= terms.reviewCreatedAtMs &&
+            now < terms.reviewExpiresAtMs &&
+            protocolCommitment(input) === terms.intentCommitment, 'LP_USEROP_REVIEW');
+        const protocol = lpUserOpProtocol(runtime);
+        const baseline = await protocol.collectProtocolEvidence(input, {
+            client: lpUserOpProtocolClient(runtime.client),
+            nowSeconds: () => Math.floor(lpUserOpNow(runtime) / 1000),
+            maxBlockAgeSeconds: finalityPolicy.maxHeadAgeSeconds,
+            maxReadDurationSeconds: finalityPolicy.maxReadDurationSeconds,
+        });
+        await assertLpUserOpAccountState(runtime, terms, BigInt(baseline.blockNumber), baseline.blockHash);
+        const preparedAtMs = lpUserOpNow(runtime), options = { now: () => Math.floor(preparedAtMs / 1000) };
+        const plan = protocol.prepare(input, baseline, options);
+        const check = protocol.validatePrepared(plan, input, baseline, options);
+        const core = {
+            version: 1,
+            kind: 'lp-collect-userop',
+            input,
+            plan,
+            baseline,
+            check,
+            terms,
+            finalityPolicy,
+            preparedAtMs,
+            validUntilMs: Math.min(input.deadline * 1000, terms.reviewExpiresAtMs),
+        };
+        const envelope = assertLpUserOpEnvelope({ ...core, commitment: hybridYieldCommitment(core) });
+        lpUserOpProtocol(runtime, envelope);
+        assertFresh(envelope, lpUserOpNow(runtime));
+        return envelope;
+    });
+}
+export async function verifyLpUserOp(runtime, rawEnvelope, independentTerms) {
+    return boundedLpUserOpRead(runtime, async () => {
+        const envelope = assertLpUserOpEnvelope(rawEnvelope), terms = LP_USEROP_TERMS_SCHEMA.parse(independentTerms);
+        requireLpUserOp(hybridYieldCommitment(terms) === hybridYieldCommitment(envelope.terms), 'LP_USEROP_REVIEW_CHANGED');
+        assertFresh(envelope, lpUserOpNow(runtime));
+        const readSpan = startLpReadSpan(runtime);
+        const protocol = lpUserOpProtocol(runtime, envelope), policy = envelope.finalityPolicy;
+        const baseline = await protocol.collectProtocolEvidence(envelope.input, {
+            client: lpUserOpProtocolClient(runtime.client),
+            nowSeconds: () => Math.floor(lpUserOpNow(runtime) / 1000),
+            maxBlockAgeSeconds: policy.maxHeadAgeSeconds,
+            maxReadDurationSeconds: policy.maxReadDurationSeconds,
+        });
+        await assertLpUserOpAccountState(runtime, terms, BigInt(baseline.blockNumber), baseline.blockHash);
+        // Preserve elapsed protocol/profile read time even when the wall clock stalls.
+        const finished = finishLpReadSpan(runtime, readSpan), verifiedAtMs = finished.wallMs;
+        const check = protocol.validatePrepared(envelope.plan, envelope.input, baseline, {
+            now: () => Math.floor(verifiedAtMs / 1000),
+        });
+        assertFresh(envelope, finished.effectiveMs);
+        const result = freezeHybridValue({ envelope, verificationOnly: true });
+        verified.set(result, freezeHybridValue(LP_USEROP_VERIFICATION_EVIDENCE_SCHEMA.parse({ baseline, check, verifiedAtMs })));
+        verifiedReadTime.set(result, {
+            monotonicAtMs: finished.monotonicMs,
+            effectiveAtMs: finished.effectiveMs,
+        });
+        assertFreshVerifiedLpUserOp(result, verifiedAtMs);
+        return result;
+    });
+}
+export function assertVerifiedLpUserOp(value) {
+    requireLpUserOp(value && verified.has(value) && Object.isFrozen(value), 'LP_USEROP_UNVERIFIED');
+    return value.envelope;
+}
+/** Final read-age boundary after every blocking writer lock and immediately before provider start. */
+export function assertFreshVerifiedLpUserOp(value, nowMs) {
+    const envelope = assertVerifiedLpUserOp(value), evidence = verified.get(value);
+    const facts = verifiedReadTime.get(value), monotonicNow = performance.now();
+    requireLpUserOp(Number.isSafeInteger(nowMs) &&
+        nowMs >= evidence.verifiedAtMs &&
+        facts !== undefined &&
+        Number.isFinite(facts.monotonicAtMs) &&
+        Number.isFinite(monotonicNow) &&
+        monotonicNow >= facts.monotonicAtMs, 'LP_USEROP_CLOCK');
+    const current = Math.max(nowMs, facts.effectiveAtMs + monotonicNow - facts.monotonicAtMs);
+    assertFresh(envelope, current);
+    const observedAtMs = evidence.baseline.observedAt * 1000, blockTimestampMs = evidence.baseline.blockTimestamp * 1000;
+    const maxHeadAgeMs = envelope.finalityPolicy.maxHeadAgeSeconds * 1000;
+    // The canonical protocol limits observation age to 30 seconds; host policy may tighten block age further.
+    requireLpUserOp(Number.isSafeInteger(observedAtMs) &&
+        Number.isSafeInteger(blockTimestampMs) &&
+        blockTimestampMs <= observedAtMs &&
+        observedAtMs <= evidence.verifiedAtMs &&
+        current - observedAtMs <= Math.min(30_000, maxHeadAgeMs) &&
+        current - blockTimestampMs <= maxHeadAgeMs, 'LP_USEROP_READ_STALE');
+}
+export function lpUserOpVerificationEvidence(value) {
+    assertVerifiedLpUserOp(value);
+    return verified.get(value);
+}
+export function lpUserOpCalls(value) {
+    return lpUserOpRecordedCalls(assertVerifiedLpUserOp(value));
+}
+/** Exact persisted request reconstruction after Stop or expiry; conveys no new sending authority. */
+export function lpUserOpRecordedCalls(rawEnvelope) {
+    return freezeHybridValue(assertLpUserOpEnvelope(rawEnvelope).plan.calls.map((call) => ({
+        to: call.to.toLowerCase(),
+        data: call.data.toLowerCase(),
+        value: '0',
+    })));
+}
+export function lpUserOpBatchData(envelope) {
+    return encodeFunctionData({
+        abi: LP_USEROP_BATCH_ABI,
+        functionName: 'executeBatch',
+        args: [
+            lpUserOpRecordedCalls(envelope).map((call) => ({
+                target: getAddress(call.to),
+                value: 0n,
+                data: call.data,
+            })),
+        ],
+    });
+}
+/** Entire reviewed executeBatch, called from the EntryPoint at the verified block, without overrides. */
+export async function simulateLpUserOp(runtime, envelope, independentTerms) {
+    return boundedLpUserOpRead(runtime, async () => {
+        const before = await verifyLpUserOp(runtime, envelope, independentTerms), evidence = lpUserOpVerificationEvidence(before);
+        const reviewed = assertVerifiedLpUserOp(before);
+        await runtime.client.call({
+            account: reviewed.terms.entryPoint,
+            to: reviewed.terms.account,
+            value: 0n,
+            data: lpUserOpBatchData(reviewed),
+            blockNumber: BigInt(evidence.baseline.blockNumber),
+        });
+        requireLpUserOp((await runtime.client.getBlock({ blockNumber: BigInt(evidence.baseline.blockNumber) }))
+            .hash === evidence.baseline.blockHash, 'LP_USEROP_SIMULATION_REORG');
+        const after = await verifyLpUserOp(runtime, reviewed, reviewed.terms);
+        requireLpUserOp(lpUserOpVerificationEvidence(after).baseline.blockHash === evidence.baseline.blockHash, 'LP_USEROP_SIMULATION_STATE_CHANGED');
+        return after;
+    });
+}
+//# sourceMappingURL=lp-userop.js.map