otto-intel-mcp 0.1.2 → 0.1.4

package/dist/lp-userop-operation.js

@@ -0,0 +1,140 @@
+/** Guarded LP collection is record v3 in the existing sponsored claim and gas ledger. */
+import { z } from 'zod';
+import { hybridYieldCommitment } from './hybrid-yield-markets.js';
+import { SPONSORED_OPERATION_SCHEMA, SPONSORED_AUTHORITY_SCHEMA, SPONSORED_ACTIVATION_SCHEMA, sponsoredDigest, sponsoredChainTerms, sponsoredActivationSupports } from './execution-sponsored-definition.js';
+import { SPONSORED_CDP_NETWORKS } from './execution-sponsored-transport.js';
+import { LP_USEROP_REVIEW_RECORD_SCHEMA } from './lp-userop-definition.js';
+import { LP_USEROP_ENVELOPE_SCHEMA, LP_USEROP_SUBMIT_EVIDENCE_SCHEMA, assertLpUserOpEnvelope, lpUserOpRecordedCalls } from './lp-userop.js';
+import { LP_USEROP_SETTLEMENT_SCHEMA } from './lp-userop-settlement.js';
+import { commitment as protocolCommitment } from './vendor/lp-v3/lp-v3-contract.js';
+const time = z.number().int().positive().safe();
+export const LP_USEROP_CONTEXT_SCHEMA = z.object({ kind: z.literal('lp-collect-userop'),
+    account: SPONSORED_AUTHORITY_SCHEMA.shape.account, chainId: z.literal(8453),
+    envelope: LP_USEROP_ENVELOPE_SCHEMA, review: LP_USEROP_REVIEW_RECORD_SCHEMA,
+    authority: SPONSORED_AUTHORITY_SCHEMA, activation: SPONSORED_ACTIVATION_SCHEMA,
+    reviewedAtMs: time, validUntilMs: time,
+}).strict();
+export const LP_USEROP_OPERATION_SCHEMA = SPONSORED_OPERATION_SCHEMA.extend({ version: z.literal(3),
+    context: LP_USEROP_CONTEXT_SCHEMA, submitEvidence: LP_USEROP_SUBMIT_EVIDENCE_SCHEMA.optional(),
+    settlement: LP_USEROP_SETTLEMENT_SCHEMA.optional(),
+}).strict();
+export function lpUserOpReviewCommitment(operationId, context, gasReview) {
+    if (gasReview)
+        return sponsoredDigest({ domain: 'otto-account-gas-review-v1', operationId, context, gasReview });
+    return sponsoredDigest({ domain: 'otto-sponsored-lp-collect-review-v1', operationId, context });
+}
+function invalid() { throw new Error('SPONSOR_LP_JOURNAL_INVALID'); }
+export function assertLpUserOpContext(context, fresh = false, nowMs = Date.now()) {
+    const envelope = assertLpUserOpEnvelope(context.envelope), terms = envelope.terms;
+    const chain = sponsoredChainTerms(context.activation, context.chainId), profile = chain.nativeYieldUserOpProfile;
+    if (context.account !== terms.account || context.chainId !== terms.chainId ||
+        context.authority.account !== context.account || context.authority.userId !== terms.userId ||
+        context.authority.activationDigest !== sponsoredDigest(context.activation) ||
+        context.authority.policyRulesDigest !== context.activation.policyRulesDigest ||
+        context.reviewedAtMs !== envelope.preparedAtMs || context.validUntilMs !== envelope.validUntilMs ||
+        context.validUntilMs > context.activation.expiresAtMs || context.validUntilMs > Date.parse(context.authority.grantExpiresAt) ||
+        hybridYieldCommitment(context.review.input) !== hybridYieldCommitment(envelope.input) ||
+        hybridYieldCommitment(context.review.terms) !== hybridYieldCommitment(terms) ||
+        !sponsoredActivationSupports(context.activation, 'lp-collect-userop') ||
+        terms.sponsoredActivationId !== context.activation.id || terms.sponsoredActivationDigest !== sponsoredDigest(context.activation) ||
+        terms.projectId !== context.activation.projectId || terms.policyId !== context.activation.policyId ||
+        terms.policyRulesDigest !== context.activation.policyRulesDigest ||
+        terms.providerEnforcementEvidenceDigest !== context.activation.providerEnforcementEvidenceDigest ||
+        context.activation.lpUserOpPolicyRelation?.lpActivationCommitment !== terms.lpActivationCommitment ||
+        context.activation.lpUserOpPolicyRelation?.compiledFullPolicyDigest !== terms.policyRulesDigest ||
+        !profile || terms.implementation !== profile.implementation || terms.implementationCodeHash !== profile.implementationCodeHash ||
+        terms.delegateBatchAbi !== profile.delegateBatchAbi || terms.delegateBatchReviewDigest !== profile.delegateBatchReviewDigest ||
+        terms.entryPointVersion !== profile.entryPointVersion || terms.delegate !== chain.delegate || terms.delegateCodeHash !== chain.delegateCodeHash ||
+        terms.entryPoint !== chain.entryPoint || terms.entryPointCodeHash !== chain.entryPointCodeHash ||
+        terms.paymaster !== chain.paymaster || terms.paymasterCodeHash !== chain.paymasterCodeHash ||
+        terms.sponsorshipPolicyId !== chain.sponsorshipPolicyId || terms.maxGasCostWei !== chain.maxGasCostWei ||
+        terms.maxUserGasCostWei !== chain.maxUserGasCostWei || terms.maxTotalGasCostWei !== chain.maxTotalGasCostWei)
+        invalid();
+    if (fresh && (context.activation.mode !== 'enabled' || context.activation.approvedAtMs > nowMs ||
+        nowMs < context.reviewedAtMs || nowMs >= context.validUntilMs))
+        throw new Error('SPONSOR_REVIEW_EXPIRED');
+}
+export function validateLpUserOpOperation(raw) {
+    const op = LP_USEROP_OPERATION_SCHEMA.parse(raw), context = op.context;
+    assertLpUserOpContext(context);
+    const { envelope } = context, { terms } = envelope;
+    if (op.userId !== context.authority.userId || op.reviewCommitment !== lpUserOpReviewCommitment(op.operationId, context, op.gasReview) ||
+        (op.state === 'review') !== !op.reviewConsumed || op.updatedAtMs < op.createdAtMs ||
+        context.reviewedAtMs !== op.createdAtMs || context.validUntilMs <= context.reviewedAtMs)
+        invalid();
+    if (op.request) {
+        const expectedBody = JSON.stringify({ network: SPONSORED_CDP_NETWORKS[context.chainId],
+            calls: lpUserOpRecordedCalls(envelope), useCdpPaymaster: false,
+            ...(op.gasReview?.payer === 'account' ? {} : { paymasterAlias: `pimlico:${context.chainId}`,
+                paymasterContext: { sponsorshipPolicyId: terms.sponsorshipPolicyId } }) });
+        if (op.request.userId !== op.userId || op.request.account !== context.account || op.request.chainId !== context.chainId ||
+            op.request.idempotencyKey !== op.operationId.slice(3) ||
+            op.request.path !== `/platform/v2/embedded-wallet-api/end-users/${op.userId}/evm/smart-accounts/${context.account.toLowerCase()}/send` ||
+            op.request.body !== expectedBody)
+            invalid();
+    }
+    if (op.handoffAttempted && !op.request)
+        invalid();
+    if (op.state === 'review' && (op.request || op.handoffAttempted || op.submitEvidence || op.userOpHash || op.transactionHash))
+        invalid();
+    if ((op.userOpHash || op.transactionHash || op.receipt) && !op.handoffAttempted)
+        invalid();
+    if (op.userOpHash && !op.submitEvidence)
+        invalid();
+    if (op.transactionHash && !op.userOpHash)
+        invalid();
+    if (op.submitEvidence) {
+        const { baseline, check, verifiedAtMs } = op.submitEvidence;
+        const { checkCommitment, ...checkCore } = check;
+        if (checkCommitment !== protocolCommitment(checkCore) || verifiedAtMs > op.updatedAtMs ||
+            verifiedAtMs < envelope.preparedAtMs || verifiedAtMs >= context.validUntilMs ||
+            check.checkedAt !== Math.floor(verifiedAtMs / 1000) || check.planCommitment !== envelope.plan.planCommitment ||
+            check.intentCommitment !== terms.intentCommitment || check.policyCommitment !== envelope.plan.policyCommitment ||
+            check.baselineCommitment !== protocolCommitment(baseline) || baseline.account !== context.account.toLowerCase() ||
+            BigInt(baseline.blockNumber) < BigInt(envelope.baseline.blockNumber) || baseline.position.approved !== terms.initialNftApproval)
+            invalid();
+    }
+    if (op.receipt && (op.receipt.userOpHash.toLowerCase() !== op.userOpHash?.toLowerCase() ||
+        op.receipt.transactionHash.toLowerCase() !== op.transactionHash?.toLowerCase() || op.receipt.chainId !== context.chainId ||
+        op.receipt.account !== context.account || op.receipt.paymaster !== (op.gasReview?.payer === 'account' ? '0x0000000000000000000000000000000000000000' : terms.paymaster) ||
+        (op.gasReview?.payer !== 'account' && BigInt(op.receipt.actualGasCostWei) > BigInt(terms.maxGasCostWei))))
+        invalid();
+    if (op.gasCapBreach && (op.gasReview?.payer === 'account' || !op.handoffAttempted || op.state !== 'submitted' || op.receipt || op.settlement ||
+        op.failureCode !== 'SPONSOR_GAS_CAP_EXCEEDED' || op.gasCapBreach.userOpHash.toLowerCase() !== op.userOpHash?.toLowerCase() ||
+        op.gasCapBreach.transactionHash.toLowerCase() !== op.transactionHash?.toLowerCase() ||
+        op.gasCapBreach.chainId !== context.chainId || op.gasCapBreach.account !== context.account ||
+        op.gasCapBreach.paymaster !== terms.paymaster || BigInt(op.gasCapBreach.actualGasCostWei) <= BigInt(terms.maxGasCostWei)))
+        invalid();
+    const result = op.settlement;
+    if (result) {
+        if (!result.releaseClaim)
+            return invalid();
+        const receipt = op.receipt;
+        if (!receipt || !op.submitEvidence || result.userOpHash !== op.userOpHash || result.transactionHash !== op.transactionHash ||
+            result.blockHash !== receipt.blockHash || result.blockNumber !== receipt.blockNumber || result.userOpNonce !== receipt.nonce ||
+            result.owner !== context.account || result.chainId !== context.chainId || result.pool !== envelope.input.pool ||
+            result.tokenId !== envelope.input.tokenId || result.planCommitment !== envelope.plan.planCommitment ||
+            result.baselineCommitment !== op.submitEvidence.check.baselineCommitment ||
+            result.actualGasCostWei !== receipt.actualGasCostWei || result.actualGasUsed !== receipt.actualGasUsed ||
+            result.paymaster !== receipt.paymaster || result.finality.policyCommitment !== protocolCommitment(envelope.finalityPolicy) ||
+            result.finality.observedAtMs < op.submitEvidence.verifiedAtMs ||
+            BigInt(result.finality.finalizedBlockNumber) < BigInt(result.blockNumber) ||
+            BigInt(result.finality.confirmations) !== BigInt(result.finality.finalizedBlockNumber) - BigInt(result.blockNumber) + 1n ||
+            BigInt(result.finality.confirmations) < BigInt(envelope.finalityPolicy.minFinalizedConfirmations))
+            invalid();
+        if (result.status === 'completed') {
+            if (op.state !== 'completed' || receipt.status !== 'success' || result.collectedRaw.some((amount, i) => BigInt(amount) > BigInt(envelope.input.amountMax[i]) || BigInt(amount) < BigInt(envelope.input.amountMin[i])))
+                invalid();
+        }
+        else if (op.state !== 'failed' || receipt.status !== 'reverted' || result.collectedRaw.some(amount => amount !== '0'))
+            invalid();
+    }
+    if (op.state === 'completed' && result?.status !== 'completed')
+        invalid();
+    if (op.state === 'failed' && op.handoffAttempted && result?.status !== 'reverted')
+        invalid();
+    if (op.state === 'submitted' && !op.userOpHash)
+        invalid();
+    return op;
+}
+//# sourceMappingURL=lp-userop-operation.js.map

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

@@ -0,0 +1,14 @@
+/** Header authorization precedes every input parse and optional LP runtime access. */
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ExecutionToolRuntime } from './execution-tools.js';
+import { type LpUserOpAvailabilityResult } from './lp-userop-mcp-definition.js';
+export interface LpUserOpBinding {
+    availability(): Promise<LpUserOpAvailabilityResult>;
+    reviewGas(input: unknown): Promise<unknown>;
+    prepare(input: unknown): Promise<unknown>;
+    submit(input: unknown): Promise<unknown>;
+    read(input: unknown): Promise<unknown>;
+    reconcile(input: unknown): Promise<unknown>;
+}
+export declare function unavailableLpUserOpBinding(reason?: NonNullable<LpUserOpAvailabilityResult['reason']>): LpUserOpBinding;
+export declare function callLpUserOp(runtime: ExecutionToolRuntime, raw: unknown, headers: Readonly<Record<string, string | string[] | undefined>> | undefined): Promise<CallToolResult>;

package/dist/lp-userop-registration.js

@@ -0,0 +1,70 @@
+import { accountGasFailure } from './execution-account-gas-view.js';
+import { LpUserOpPreHandoffRefusal } from './lp-userop-account.js';
+import { ZodError } from 'zod';
+import { assertDelegationCaller, callerFromHeaders } from './execution-delegation.js';
+import { ExecutionRefusal, isExecutionRefusal } from './execution-errors.js';
+import { SponsoredAccountRefusal } from './execution-sponsored-runtime.js';
+import { lpUserOpAvailability } from './lp-userop-index.js';
+import { LP_USEROP_ACTION_INPUT, LP_USEROP_TOOL_RESULT, LP_USEROP_AVAILABILITY_RESULT } from './lp-userop-mcp-definition.js';
+export function unavailableLpUserOpBinding(reason = 'SPONSOR_ACTIVATION_UNCONFIGURED') {
+    const refuse = async () => { throw new SponsoredAccountRefusal(reason); };
+    return Object.freeze({ availability: async () => LP_USEROP_AVAILABILITY_RESULT.parse({ ...lpUserOpAvailability(),
+            executionEnabled: false, recoveryAvailable: false, reason }),
+        reviewGas: refuse, prepare: refuse, submit: refuse, read: refuse, reconcile: refuse });
+}
+function success(raw) {
+    const output = LP_USEROP_TOOL_RESULT.parse(raw);
+    return { content: [{ type: 'text', text: JSON.stringify(output) }], structuredContent: output };
+}
+// Factory refusals occur before the service can start this invocation. Arbitrary errors remain unknown.
+const BEFORE_HANDOFF_REFUSALS = new Set(['SPONSOR_ACTIVATION_UNCONFIGURED', 'SPONSOR_ACTIVATION_UNAVAILABLE',
+    'SPONSOR_CAPABILITY_UNAVAILABLE', 'SPONSOR_RECOVERY_ONLY', 'SPONSOR_RUNTIME_UNAVAILABLE',
+    'SPONSOR_JOURNAL_UNAVAILABLE', 'SPONSOR_CAP_UNAVAILABLE', 'SPONSOR_CHAIN_UNAVAILABLE']);
+export async function callLpUserOp(runtime, raw, headers) {
+    let submitId, invoked = false;
+    try {
+        if (!runtime.delegation)
+            throw new ExecutionRefusal('DELEGATION_UNAUTHORIZED', 'Protected account caller is not authorized');
+        assertDelegationCaller(runtime.delegation, callerFromHeaders(headers));
+        const input = LP_USEROP_ACTION_INPUT.parse(raw), binding = runtime.lpUserOp ?? unavailableLpUserOpBinding();
+        if (input.action === 'availability')
+            return success(LP_USEROP_AVAILABILITY_RESULT.parse(await binding.availability()));
+        const { action, ...body } = input;
+        if (action === 'submit')
+            submitId = input.operationId;
+        invoked = true;
+        const result = LP_USEROP_TOOL_RESULT.parse(await binding[action](body));
+        if (!('state' in result) || !('operationId' in result))
+            throw new Error('mismatched operation');
+        if (action === 'prepare') {
+            if (result.state !== 'review' || result.account.toLowerCase() !== input.input.account ||
+                result.chainId !== input.input.chainId || result.pool !== input.input.pool || result.tokenId !== input.input.tokenId ||
+                JSON.stringify(result.collection.maximum) !== JSON.stringify(input.input.amountMax) ||
+                JSON.stringify(result.collection.minimum) !== JSON.stringify(input.input.amountMin))
+                throw new Error('mismatched preparation');
+        }
+        else if (result.operationId !== input.operationId)
+            throw new Error('mismatched operation');
+        if (input.action === 'reviewGas' && (result.state !== 'review' || result.reviewConsumed || result.gas.reviewRequired !== true || !result.gas.paymentReview ||
+            result.reviewCommitment === input.reviewCommitment || (input.preference !== 'auto' && result.gas.payer !== input.preference)))
+            throw new Error('mismatched gas review');
+        if (action === 'submit' && (!result.reviewConsumed || result.envelopeCommitment !== input.envelopeCommitment ||
+            result.reviewCommitment !== input.reviewCommitment))
+            throw new Error('mismatched consumed review');
+        return success(result);
+    }
+    catch (error) {
+        const knownRefusal = error instanceof LpUserOpPreHandoffRefusal ||
+            (error instanceof SponsoredAccountRefusal && BEFORE_HANDOFF_REFUSALS.has(error.code));
+        if (submitId && invoked && !knownRefusal)
+            return success({ schemaVersion: '1', kind: 'lp-collect-userop', status: 'outcome-unknown', operationId: submitId,
+                requiresReconciliation: true, replacementPermitted: false,
+                attention: 'The outcome of the original submission is unknown. Read or reconcile this operation; do not submit a replacement.' });
+        const denied = isExecutionRefusal(error) && error.code === 'DELEGATION_UNAUTHORIZED' && !invoked;
+        const code = denied ? 'DELEGATION_UNAUTHORIZED' : error instanceof ZodError && !invoked
+            ? 'LP_USEROP_REQUEST_INVALID' : accountGasFailure(error) ?? 'LP_USEROP_REQUEST_REFUSED';
+        return { isError: true, content: [{ type: 'text', text: JSON.stringify({ status: 'refused', code,
+                        message: denied ? 'The protected account caller is not authorized.' : 'The LP collection action is unavailable or refused. Read current availability and the original operation before continuing.' }) }] };
+    }
+}
+//# sourceMappingURL=lp-userop-registration.js.map

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

@@ -0,0 +1,89 @@
+/** Canonical EntryPoint transaction and isolated LP accounting proof. Never sends or retries. */
+import { type Hex } from 'viem';
+import { z } from 'zod';
+import { type LpUserOpEnvelope, type LpUserOpRuntime, type LpUserOpSubmitEvidence } from './lp-userop.js';
+export declare const LP_USEROP_SETTLEMENT_SCHEMA: z.ZodUnion<readonly [z.ZodObject<{
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        held: "held";
+    }>;
+    reason: z.ZodString;
+    userOpHash: z.ZodString;
+    transactionHash: z.ZodString;
+    releaseClaim: z.ZodLiteral<false>;
+    retrySafe: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    userOpHash: z.ZodString;
+    transactionHash: z.ZodString;
+    blockHash: z.ZodString;
+    blockNumber: z.ZodString;
+    userOpNonce: z.ZodString;
+    owner: z.ZodString;
+    chainId: z.ZodLiteral<8453>;
+    pool: z.ZodString;
+    tokenId: z.ZodString;
+    planCommitment: z.ZodString;
+    baselineCommitment: z.ZodString;
+    accountingCommitment: z.ZodString;
+    collectedRaw: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    liquidityDelta: z.ZodLiteral<"0">;
+    ownerBalancesAtBlock: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    nftTokenApprovalCleared: z.ZodLiteral<true>;
+    erc20AllowancesCleared: z.ZodLiteral<true>;
+    actualGasCostWei: z.ZodString;
+    actualGasUsed: z.ZodString;
+    paymaster: z.ZodString;
+    profitClassification: z.ZodLiteral<"UNKNOWN">;
+    distributableProfitRaw: z.ZodNull;
+    releaseClaim: z.ZodLiteral<true>;
+    retrySafe: z.ZodLiteral<false>;
+    finality: z.ZodObject<{
+        policyCommitment: z.ZodString;
+        observedAtMs: z.ZodNumber;
+        finalizedBlockNumber: z.ZodString;
+        finalizedBlockHash: z.ZodString;
+        confirmations: z.ZodString;
+    }, z.core.$strict>;
+    status: z.ZodLiteral<"completed">;
+    protocolActionVerified: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+    userOpHash: z.ZodString;
+    transactionHash: z.ZodString;
+    blockHash: z.ZodString;
+    blockNumber: z.ZodString;
+    userOpNonce: z.ZodString;
+    owner: z.ZodString;
+    chainId: z.ZodLiteral<8453>;
+    pool: z.ZodString;
+    tokenId: z.ZodString;
+    planCommitment: z.ZodString;
+    baselineCommitment: z.ZodString;
+    accountingCommitment: z.ZodString;
+    collectedRaw: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    liquidityDelta: z.ZodLiteral<"0">;
+    ownerBalancesAtBlock: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    nftTokenApprovalCleared: z.ZodLiteral<true>;
+    erc20AllowancesCleared: z.ZodLiteral<true>;
+    actualGasCostWei: z.ZodString;
+    actualGasUsed: z.ZodString;
+    paymaster: z.ZodString;
+    profitClassification: z.ZodLiteral<"UNKNOWN">;
+    distributableProfitRaw: z.ZodNull;
+    releaseClaim: z.ZodLiteral<true>;
+    retrySafe: z.ZodLiteral<false>;
+    finality: z.ZodObject<{
+        policyCommitment: z.ZodString;
+        observedAtMs: z.ZodNumber;
+        finalizedBlockNumber: z.ZodString;
+        finalizedBlockHash: z.ZodString;
+        confirmations: z.ZodString;
+    }, z.core.$strict>;
+    status: z.ZodLiteral<"reverted">;
+    protocolActionVerified: z.ZodLiteral<false>;
+}, z.core.$strict>]>;
+export type LpUserOpSettlement = z.infer<typeof LP_USEROP_SETTLEMENT_SCHEMA>;
+export interface LpUserOpReceiptBinding {
+    readonly userOpHash: Hex;
+    readonly transactionHash: Hex;
+}
+export declare function readLpUserOpSettlement(rawEnvelope: LpUserOpEnvelope, binding: LpUserOpReceiptBinding, runtime: LpUserOpRuntime, rawSubmitEvidence: LpUserOpSubmitEvidence, payer?: 'sponsor' | 'account'): Promise<LpUserOpSettlement>;

package/dist/lp-userop-settlement.js

@@ -0,0 +1,184 @@
+/** Canonical EntryPoint transaction and isolated LP accounting proof. Never sends or retries. */
+import { decodeEventLog, decodeFunctionData, encodeFunctionData, keccak256, parseAbi, recoverTransactionAddress, serializeTransaction } from 'viem';
+import { getUserOperationHash } from 'viem/account-abstraction';
+import { z } from 'zod';
+import { freezeHybridValue } from './hybrid-yield-markets.js';
+import { readConfirmedSponsoredReceipt, SponsoredReceiptUnconfirmedError } from './execution-sponsored-receipt.js';
+import { sponsoredOperationLogs } from './execution-sponsored-settlement.js';
+import { commitment as protocolCommitment } from './vendor/lp-v3/lp-v3-contract.js';
+import { lpV3CollectProtocolEvidenceSchema } from './vendor/lp-v3/lp-v3-collect-protocol-contract.js';
+import { assertLpUserOpEnvelope, assertLpUserOpAccountState, boundedLpUserOpRead, lpUserOpBatchData, lpUserOpNow, lpUserOpProtocol, lpUserOpProtocolClient, requireLpUserOp, LP_USEROP_SUBMIT_EVIDENCE_SCHEMA, LpUserOpError } from './lp-userop.js';
+const EP_ABI = parseAbi([
+    'function handleOps((address sender,uint256 nonce,bytes initCode,bytes callData,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,bytes paymasterAndData,bytes signature)[] ops,address beneficiary)',
+    'event UserOperationEvent(bytes32 indexed userOpHash,address indexed sender,address indexed paymaster,uint256 nonce,bool success,uint256 actualGasCost,uint256 actualGasUsed)',
+    'event BeforeExecution()',
+]);
+const hash = z.string().regex(/^0x[0-9a-fA-F]{64}$/), uint = z.string().regex(/^(0|[1-9][0-9]*)$/);
+const held = z.object({ status: z.enum(['held', 'unknown']), reason: z.string(), userOpHash: hash, transactionHash: hash,
+    releaseClaim: z.literal(false), retrySafe: z.literal(false) }).strict();
+const accounted = z.object({
+    userOpHash: hash, transactionHash: hash, blockHash: hash, blockNumber: uint, userOpNonce: uint,
+    owner: z.string(), chainId: z.literal(8453), pool: z.string(), tokenId: uint, planCommitment: hash,
+    baselineCommitment: hash, accountingCommitment: hash, collectedRaw: z.tuple([uint, uint]), liquidityDelta: z.literal('0'),
+    ownerBalancesAtBlock: z.tuple([uint, uint]), nftTokenApprovalCleared: z.literal(true), erc20AllowancesCleared: z.literal(true),
+    actualGasCostWei: uint, actualGasUsed: uint, paymaster: z.string(),
+    profitClassification: z.literal('UNKNOWN'), distributableProfitRaw: z.null(),
+    releaseClaim: z.literal(true), retrySafe: z.literal(false),
+    finality: z.object({ policyCommitment: hash, observedAtMs: z.number().int().positive().safe(),
+        finalizedBlockNumber: uint, finalizedBlockHash: hash, confirmations: uint }).strict(),
+});
+export const LP_USEROP_SETTLEMENT_SCHEMA = z.union([held,
+    accounted.extend({ status: z.literal('completed'), protocolActionVerified: z.literal(true) }).strict(),
+    accounted.extend({ status: z.literal('reverted'), protocolActionVerified: z.literal(false) }).strict(),
+]);
+const same = (a, b) => typeof a === 'string' && a.toLowerCase() === b.toLowerCase();
+async function proveTransaction(runtime, envelope, binding, receipt, nonce, payer) {
+    const tx = await runtime.client.getTransaction({ hash: binding.transactionHash }), terms = envelope.terms;
+    requireLpUserOp(tx.type === 'eip1559' && tx.chainId === terms.chainId && same(tx.hash, binding.transactionHash) &&
+        same(tx.to, terms.entryPoint) && tx.value === 0n && same(tx.blockHash, receipt.blockHash) && tx.blockNumber === receipt.blockNumber &&
+        tx.transactionIndex === receipt.transactionIndex && same(tx.from, receipt.from) && same(receipt.to, terms.entryPoint) &&
+        Number.isSafeInteger(tx.nonce) && tx.nonce >= 0 && tx.gas > 0n && tx.maxFeePerGas > 0n &&
+        tx.maxPriorityFeePerGas >= 0n && tx.maxPriorityFeePerGas <= tx.maxFeePerGas &&
+        (tx.yParity === 0 || tx.yParity === 1) && BigInt(tx.r) > 0n &&
+        BigInt(tx.r) < 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n &&
+        BigInt(tx.s) > 0n && BigInt(tx.s) <= 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0n, 'LP_USEROP_TRANSACTION_BINDING');
+    const serialized = serializeTransaction({ type: 'eip1559', chainId: tx.chainId, nonce: tx.nonce, gas: tx.gas,
+        maxFeePerGas: tx.maxFeePerGas, maxPriorityFeePerGas: tx.maxPriorityFeePerGas, to: tx.to, value: tx.value,
+        data: tx.input, accessList: tx.accessList }, { r: tx.r, s: tx.s, yParity: tx.yParity });
+    requireLpUserOp(same(keccak256(serialized), binding.transactionHash) &&
+        same(await recoverTransactionAddress({ serializedTransaction: serialized }), tx.from), 'LP_USEROP_TRANSACTION_SIGNATURE');
+    const decoded = decodeFunctionData({ abi: EP_ABI, data: tx.input });
+    requireLpUserOp(decoded.functionName === 'handleOps' && decoded.args[0].length > 0 && decoded.args[0].length <= 256 &&
+        encodeFunctionData({ abi: EP_ABI, functionName: 'handleOps', args: decoded.args }) === tx.input, 'LP_USEROP_UNSUPPORTED_BUNDLE');
+    const operations = decoded.args[0].map(operation => ({ operation, hash: getUserOperationHash({ chainId: terms.chainId,
+            entryPointAddress: terms.entryPoint, entryPointVersion: '0.6', userOperation: operation }) }));
+    const matching = operations.filter(operation => same(operation.hash, binding.userOpHash));
+    requireLpUserOp(matching.length === 1 && operations.filter(({ operation }) => same(operation.sender, terms.account)).length === 1, 'LP_USEROP_HASH');
+    const operation = matching[0].operation;
+    requireLpUserOp(same(operation.sender, terms.account) && operation.nonce.toString() === nonce &&
+        operation.initCode === '0x' && same(operation.callData, lpUserOpBatchData(envelope)) &&
+        (payer === 'account' ? operation.paymasterAndData === '0x' :
+            operation.paymasterAndData.length >= 42 && same(operation.paymasterAndData.slice(0, 42), terms.paymaster)) &&
+        operation.callGasLimit > 0n && operation.verificationGasLimit > 0n && operation.preVerificationGas > 0n &&
+        operation.maxFeePerGas > 0n && operation.maxPriorityFeePerGas <= operation.maxFeePerGas, 'LP_USEROP_CALLDATA');
+    const events = [];
+    let beforeExecution = -1;
+    for (const log of receipt.logs) {
+        if (!same(log.address, terms.entryPoint))
+            continue;
+        let event;
+        try {
+            event = decodeEventLog({ abi: EP_ABI, data: log.data, topics: log.topics, strict: true });
+        }
+        catch {
+            continue;
+        }
+        if (event.eventName === 'BeforeExecution') {
+            requireLpUserOp(beforeExecution === -1 && events.length === 0, 'LP_USEROP_BUNDLE_BOUNDARY');
+            beforeExecution = log.logIndex;
+        }
+        else if (event.eventName === 'UserOperationEvent') {
+            requireLpUserOp(beforeExecution >= 0, 'LP_USEROP_BUNDLE_BOUNDARY');
+            events.push({ hash: event.args.userOpHash, sender: event.args.sender, nonce: event.args.nonce, index: log.logIndex });
+        }
+    }
+    requireLpUserOp(events.length === operations.length && events.every((event, i) => same(event.hash, operations[i].hash) &&
+        same(event.sender, operations[i].operation.sender) && event.nonce === operations[i].operation.nonce), 'LP_USEROP_BUNDLE_EVENTS');
+    const eventIndex = events.findIndex(event => same(event.hash, binding.userOpHash));
+    requireLpUserOp(eventIndex >= 0, 'LP_USEROP_BUNDLE_EVENTS');
+    return { windowStartLogIndex: eventIndex === 0 ? beforeExecution : events[eventIndex - 1].index,
+        userOpEventLogIndex: events[eventIndex].index };
+}
+export async function readLpUserOpSettlement(rawEnvelope, binding, runtime, rawSubmitEvidence, payer = 'sponsor') {
+    const retain = (reason, status = 'held') => ({ status, reason, ...binding, releaseClaim: false, retrySafe: false });
+    try {
+        return await boundedLpUserOpRead(runtime, async () => {
+            const envelope = assertLpUserOpEnvelope(rawEnvelope), submit = LP_USEROP_SUBMIT_EVIDENCE_SCHEMA.parse(rawSubmitEvidence);
+            const { plan, input, terms, finalityPolicy: policy } = envelope, protocol = lpUserOpProtocol(runtime, envelope);
+            requireLpUserOp(submit.verifiedAtMs >= envelope.preparedAtMs && submit.verifiedAtMs < envelope.validUntilMs &&
+                submit.check.checkedAt === Math.floor(submit.verifiedAtMs / 1000), 'LP_USEROP_SUBMIT_BASELINE');
+            const checked = protocol.validatePrepared(plan, input, submit.baseline, { now: () => submit.check.checkedAt });
+            requireLpUserOp(protocolCommitment(checked) === protocolCommitment(submit.check), 'LP_USEROP_SUBMIT_CHECK');
+            // Seal the finalized boundary before reading either transaction or historical account state.
+            const [finalized, latest] = await Promise.all([runtime.client.getBlock({ blockTag: 'finalized' }), runtime.client.getBlock({ blockTag: 'latest' })]);
+            const observedAtMs = lpUserOpNow(runtime), now = Math.floor(observedAtMs / 1000);
+            requireLpUserOp(finalized.number !== null && finalized.hash && latest.number !== null && latest.hash &&
+                finalized.number <= latest.number && finalized.timestamp <= latest.timestamp &&
+                Number(latest.timestamp) <= now && now - Number(latest.timestamp) <= policy.maxHeadAgeSeconds &&
+                now - Number(finalized.timestamp) <= policy.maxFinalizedLagSeconds, 'LP_USEROP_FINALITY_STALE');
+            const confirmed = await readConfirmedSponsoredReceipt({ ...binding, chainId: terms.chainId, account: terms.account,
+                payer, entryPoint: terms.entryPoint, paymaster: payer === 'account' ? '0x0000000000000000000000000000000000000000' : terms.paymaster, maxGasCostWei: BigInt(terms.maxGasCostWei) }, runtime.client);
+            const receipt = await runtime.client.getTransactionReceipt({ hash: binding.transactionHash });
+            requireLpUserOp(receipt.transactionHash === confirmed.transactionHash && receipt.blockHash === confirmed.blockHash &&
+                receipt.blockNumber.toString() === confirmed.blockNumber && receipt.type === 'eip1559' &&
+                Number.isSafeInteger(receipt.transactionIndex) && receipt.transactionIndex >= 0 &&
+                receipt.gasUsed > 0n && receipt.effectiveGasPrice > 0n && receipt.cumulativeGasUsed >= receipt.gasUsed &&
+                receipt.logs.length > 0 && receipt.logs.length <= 4096 && receipt.logs.every((log, i) => !log.removed &&
+                log.transactionHash === receipt.transactionHash && log.transactionIndex === receipt.transactionIndex && log.blockHash === receipt.blockHash &&
+                log.blockNumber === receipt.blockNumber && Number.isSafeInteger(log.logIndex) && log.logIndex >= 0 &&
+                (i === 0 || log.logIndex === receipt.logs[i - 1].logIndex + 1)), 'LP_USEROP_RECEIPT_BINDING');
+            const confirmations = finalized.number - receipt.blockNumber + 1n;
+            requireLpUserOp(confirmations >= BigInt(policy.minFinalizedConfirmations), 'LP_USEROP_NOT_FINALIZED');
+            const block = await runtime.client.getBlock({ blockNumber: receipt.blockNumber });
+            requireLpUserOp(block.number === receipt.blockNumber && block.hash === receipt.blockHash &&
+                receipt.blockNumber > BigInt(submit.baseline.blockNumber) && block.timestamp <= finalized.timestamp &&
+                Number(block.timestamp) > submit.baseline.blockTimestamp &&
+                (confirmed.status === 'reverted' || Number(block.timestamp) <= input.deadline) && same(typeof block.transactions[receipt.transactionIndex] === 'string'
+                ? block.transactions[receipt.transactionIndex] : undefined, binding.transactionHash), 'LP_USEROP_BLOCK_BINDING');
+            const bounds = await proveTransaction(runtime, envelope, binding, receipt, confirmed.nonce, payer);
+            const historical = await protocol.collectProtocolEvidence(input, { client: lpUserOpProtocolClient(runtime.client),
+                nowSeconds: () => Math.floor(lpUserOpNow(runtime) / 1000), maxBlockAgeSeconds: policy.maxHeadAgeSeconds,
+                maxReadDurationSeconds: policy.maxReadDurationSeconds,
+                historicalAnchor: { number: submit.baseline.blockNumber, hash: submit.baseline.blockHash, timestamp: submit.baseline.blockTimestamp } });
+            // The new historical read has a CURRENT observation time. All chain fields must match the original
+            // submission baseline exactly; the persisted check continues to bind its original observation time.
+            const { observedAt: _newReadTime, ...historicalState } = historical;
+            const { observedAt: _originalReadTime, ...originalState } = submit.baseline;
+            requireLpUserOp(protocolCommitment(historicalState) === protocolCommitment(originalState), 'LP_USEROP_BASELINE_CHANGED');
+            await assertLpUserOpAccountState(runtime, terms, BigInt(submit.baseline.blockNumber), submit.baseline.blockHash);
+            await assertLpUserOpAccountState(runtime, terms, receipt.blockNumber, receipt.blockHash);
+            const post = await protocol.collectProtocolEvidence(input, { client: lpUserOpProtocolClient(runtime.client), nowSeconds: () => Math.floor(lpUserOpNow(runtime) / 1000),
+                maxBlockAgeSeconds: policy.maxHeadAgeSeconds, maxReadDurationSeconds: policy.maxReadDurationSeconds,
+                historicalAnchor: { number: receipt.blockNumber.toString(), hash: receipt.blockHash, timestamp: Number(block.timestamp) } });
+            const logs = sponsoredOperationLogs(receipt, terms.entryPoint, binding.userOpHash);
+            const evidence = lpV3CollectProtocolEvidenceSchema.parse({ schemaVersion: 3, planCommitment: plan.planCommitment,
+                status: confirmed.status, binding: { ...binding, ...bounds, chainId: terms.chainId, account: terms.account.toLowerCase(),
+                    entryPoint: terms.entryPoint.toLowerCase(), blockNumber: receipt.blockNumber.toString(), blockHash: receipt.blockHash,
+                    blockTimestamp: Number(block.timestamp), transactionIndex: receipt.transactionIndex, userOpNonce: confirmed.nonce },
+                logs: logs.map(log => ({ address: log.address.toLowerCase(), topics: log.topics, data: log.data, logIndex: log.logIndex,
+                    transactionHash: log.transactionHash, transactionIndex: log.transactionIndex, blockHash: log.blockHash,
+                    blockNumber: log.blockNumber.toString(), removed: false })), post });
+            const accounting = protocol.reconcileCollectProtocol({ plan, independentIntent: input, baseline: submit.baseline, check: submit.check, evidence }, { now: () => Math.floor(lpUserOpNow(runtime) / 1000) });
+            if (accounting.status !== 'PROTOCOL_ACCOUNTED')
+                return retain(`LP_USEROP_PROTOCOL_${accounting.reason}`);
+            requireLpUserOp(accounting.outcome === (confirmed.status === 'success' ? 'collected' : 'reverted') &&
+                same(accounting.userOpHash, binding.userOpHash) && same(accounting.transactionHash, binding.transactionHash), 'LP_USEROP_ACCOUNTING_BINDING');
+            const [finalizedAnchor, receiptAnchor, baselineAnchor, latestAnchor, chainId] = await Promise.all([
+                runtime.client.getBlock({ blockNumber: finalized.number }), runtime.client.getBlock({ blockNumber: receipt.blockNumber }),
+                runtime.client.getBlock({ blockNumber: BigInt(submit.baseline.blockNumber) }), runtime.client.getBlock({ blockNumber: latest.number }),
+                runtime.client.getChainId(),
+            ]);
+            requireLpUserOp(chainId === terms.chainId && finalizedAnchor.hash === finalized.hash && receiptAnchor.hash === receipt.blockHash &&
+                baselineAnchor.hash === submit.baseline.blockHash && latestAnchor.hash === latest.hash &&
+                Math.floor(lpUserOpNow(runtime) / 1000) - Number(latest.timestamp) <= policy.maxHeadAgeSeconds, 'LP_USEROP_REORG');
+            return freezeHybridValue(LP_USEROP_SETTLEMENT_SCHEMA.parse({
+                ...binding, blockHash: receipt.blockHash, blockNumber: receipt.blockNumber.toString(), userOpNonce: confirmed.nonce,
+                owner: terms.account, chainId: terms.chainId, pool: input.pool, tokenId: input.tokenId, planCommitment: plan.planCommitment,
+                baselineCommitment: accounting.baselineCommitment, accountingCommitment: accounting.accountingCommitment,
+                collectedRaw: accounting.collectedRaw, liquidityDelta: '0', ownerBalancesAtBlock: accounting.ownerBalancesAtBlock,
+                nftTokenApprovalCleared: true, erc20AllowancesCleared: true, actualGasCostWei: confirmed.actualGasCostWei,
+                actualGasUsed: confirmed.actualGasUsed, paymaster: confirmed.paymaster, profitClassification: 'UNKNOWN', distributableProfitRaw: null,
+                releaseClaim: true, retrySafe: false, finality: { policyCommitment: protocolCommitment(policy), observedAtMs,
+                    finalizedBlockNumber: finalized.number.toString(), finalizedBlockHash: finalized.hash, confirmations: confirmations.toString() },
+                status: confirmed.status === 'success' ? 'completed' : 'reverted', protocolActionVerified: confirmed.status === 'success',
+            }));
+        });
+    }
+    catch (error) {
+        // The shared sponsor circuit needs the exact proven breach, including after Stop and expiry.
+        if (error instanceof SponsoredReceiptUnconfirmedError && error.code === 'SPONSOR_GAS_CAP_EXCEEDED')
+            throw error;
+        return retain(error instanceof LpUserOpError ? error.code : 'LP_USEROP_EVIDENCE_UNAVAILABLE', 'unknown');
+    }
+}
+//# sourceMappingURL=lp-userop-settlement.js.map