otto-intel-mcp 0.1.2 → 0.1.4

package/dist/native-yield-userop-operation.js

@@ -0,0 +1,127 @@
+/** Native UserOps are a typed record in the existing sponsored table and gas budget. */
+import { z } from 'zod';
+import { hybridYieldCommitment, getHybridYieldMarket } from './hybrid-yield-markets.js';
+import { nativeYieldFee } from './native-yield-definition.js';
+import { SPONSORED_OPERATION_SCHEMA, SPONSORED_AUTHORITY_SCHEMA, SPONSORED_ACTIVATION_SCHEMA, SPONSORED_CHAIN_SCHEMA, sponsoredDigest, sponsoredChainTerms, sponsoredActivationSupports } from './execution-sponsored-definition.js';
+import { SPONSORED_CDP_NETWORKS } from './execution-sponsored-transport.js';
+import { NATIVE_YIELD_USEROP_ENVELOPE_SCHEMA, NATIVE_YIELD_USEROP_SETTLEMENT_SCHEMA } from './native-yield-userop-definition.js';
+import { NATIVE_YIELD_USEROP_REVIEW_RECORD_SCHEMA } from './native-yield-userop-authority.js';
+import { assertNativeYieldUserOpEnvelope, nativeYieldUserOpRecordedCalls } from './native-yield-userop.js';
+const time = z.number().int().positive().safe();
+export const NATIVE_USEROP_CONTEXT_SCHEMA = z.object({ kind: z.literal('native-yield-userop'),
+    account: SPONSORED_AUTHORITY_SCHEMA.shape.account, chainId: SPONSORED_CHAIN_SCHEMA,
+    envelope: NATIVE_YIELD_USEROP_ENVELOPE_SCHEMA, review: NATIVE_YIELD_USEROP_REVIEW_RECORD_SCHEMA,
+    authority: SPONSORED_AUTHORITY_SCHEMA, activation: SPONSORED_ACTIVATION_SCHEMA,
+    reviewedAtMs: time, validUntilMs: time,
+}).strict();
+export const NATIVE_USEROP_OPERATION_SCHEMA = SPONSORED_OPERATION_SCHEMA.extend({ version: z.literal(2),
+    context: NATIVE_USEROP_CONTEXT_SCHEMA, settlement: NATIVE_YIELD_USEROP_SETTLEMENT_SCHEMA.optional(),
+}).strict();
+export function nativeUserOpReviewCommitment(operationId, context, gasReview) {
+    if (gasReview)
+        return sponsoredDigest({ domain: 'otto-account-gas-review-v1', operationId, context, gasReview });
+    return sponsoredDigest({ domain: 'otto-sponsored-native-yield-review-v1', operationId, context });
+}
+function invalid() { throw new Error('SPONSOR_NATIVE_JOURNAL_INVALID'); }
+export function assertNativeUserOpContext(context, fresh = false, nowMs = Date.now()) {
+    const envelope = assertNativeYieldUserOpEnvelope(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, 'native-yield-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 ||
+        terms.nativeActivationCommitment !== context.activation.nativeYieldUserOpPolicyRelation?.nativeActivationCommitment ||
+        (context.activation.lpUserOpPolicyRelation?.compiledFullPolicyDigest ??
+            context.activation.nativeYieldUserOpPolicyRelation?.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 validateNativeUserOpOperation(raw) {
+    const op = NATIVE_USEROP_OPERATION_SCHEMA.parse(raw), context = op.context;
+    assertNativeUserOpContext(context);
+    const { plan, terms } = context.envelope;
+    if (op.userId !== context.authority.userId ||
+        op.reviewCommitment !== nativeUserOpReviewCommitment(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: nativeYieldUserOpRecordedCalls(context.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.userOpHash || op.transactionHash))
+        invalid();
+    if ((op.userOpHash || op.transactionHash || op.receipt) && !op.handoffAttempted)
+        invalid();
+    if (op.transactionHash && !op.userOpHash)
+        invalid();
+    const boundReceipt = (receipt) => receipt.userOpHash.toLowerCase() === op.userOpHash?.toLowerCase() &&
+        receipt.transactionHash.toLowerCase() === op.transactionHash?.toLowerCase() &&
+        receipt.chainId === context.chainId && receipt.account === context.account && receipt.paymaster === (op.gasReview?.payer === 'account' ? '0x0000000000000000000000000000000000000000' : terms.paymaster);
+    if (op.receipt && (!boundReceipt(op.receipt) || (op.gasReview?.payer !== 'account' && BigInt(op.receipt.actualGasCostWei) > BigInt(terms.maxGasCostWei))))
+        invalid();
+    if (op.gasCapBreach && (op.gasReview?.payer === 'account' || !boundReceipt(op.gasCapBreach) || !op.handoffAttempted || op.state !== 'submitted' ||
+        op.receipt || op.settlement || op.failureCode !== 'SPONSOR_GAS_CAP_EXCEEDED' ||
+        BigInt(op.gasCapBreach.actualGasCostWei) <= BigInt(terms.maxGasCostWei)))
+        invalid();
+    const result = op.settlement;
+    if (result) {
+        const receipt = op.receipt, market = getHybridYieldMarket(plan.marketId);
+        if (!receipt || result.transactionHash !== receipt.transactionHash || result.userOpHash !== receipt.userOpHash ||
+            result.blockHash !== receipt.blockHash || result.blockNumber !== receipt.blockNumber ||
+            result.owner !== context.account || result.marketId !== plan.marketId || result.action !== plan.action ||
+            result.actualGasCostWei !== receipt.actualGasCostWei || result.actualGasUsed !== receipt.actualGasUsed ||
+            result.paymaster !== receipt.paymaster)
+            invalid();
+        if (result.status === 'completed') {
+            if (op.state !== 'completed' || receipt.status !== 'success' || result.actualInput !== plan.amount ||
+                BigInt(result.actualOutput) < BigInt(plan.minimumOutput) || result.feeToken !== market.asset.address ||
+                BigInt(result.actualOttoFee) !== nativeYieldFee(plan.action === 'deposit' ? BigInt(plan.amount)
+                    : BigInt(result.actualOutput) + BigInt(result.actualOttoFee)) ||
+                BigInt(result.routerNonceAtBlock) < BigInt(plan.nonce) + 1n)
+                invalid();
+        }
+        else if (op.state !== 'failed' || receipt.status !== 'reverted' ||
+            BigInt(result.routerNonceAtBlock) !== BigInt(plan.nonce))
+            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=native-yield-userop-operation.js.map

package/dist/native-yield-userop-policy.d.ts

@@ -0,0 +1,23 @@
+import { type NativeYieldAccountActivation } from './native-yield-account-definition.js';
+/**
+ * Installed CDP SDK SendEndUserOperationRule and official create-policy schema name the end-user
+ * operation sendEndUserOperation. sendUserOperation is a different server-wallet operation.
+ * This exact compiler adds native calls only; it does not enable sponsored LI.FI swaps.
+ * https://docs.cdp.coinbase.com/api-reference/v2/rest-api/policy-engine/create-policy
+ * Source review must include provider rejection of a forbidden call in the actual end-user batch.
+ */
+export declare function compileNativeYieldEndUserOperationPolicy(activation: NativeYieldAccountActivation): {
+    body: {
+        scope: "project";
+        description: "OTTO model b swap fence v3";
+        rules: (import("./execution-delegation-policy.js").DelegationPolicyRule | {
+            operation: "sendEndUserOperation";
+            action: "accept";
+            criteria: readonly import("./native-yield-account-policy.js").NativeYieldAccountPolicyCriterion[];
+        })[];
+    };
+    nativeActivationCommitment: `sha256:${string}`;
+    nativeRulesDigest: string;
+    compiledFullPolicyDigest: string;
+    compiler: "legacy-v2-native-enduser-userop-v1";
+};

package/dist/native-yield-userop-policy.js

@@ -0,0 +1,25 @@
+/** Pure reviewed native policy compiler shared by native-only and explicit composite policies. */
+import { freezeHybridValue } from './hybrid-yield-markets.js';
+import { policyRulesDigest } from './execution-policy-compatibility.js';
+import { NATIVE_ACCOUNT_POLICY_NAME } from './native-yield-account-definition.js';
+import { nativeYieldAccountActivationCommitment, validateNativeYieldAccountActivation } from './native-yield-account-policy.js';
+import { refuseNative } from './native-yield-definition.js';
+/**
+ * Installed CDP SDK SendEndUserOperationRule and official create-policy schema name the end-user
+ * operation sendEndUserOperation. sendUserOperation is a different server-wallet operation.
+ * This exact compiler adds native calls only; it does not enable sponsored LI.FI swaps.
+ * https://docs.cdp.coinbase.com/api-reference/v2/rest-api/policy-engine/create-policy
+ * Source review must include provider rejection of a forbidden call in the actual end-user batch.
+ */
+export function compileNativeYieldEndUserOperationPolicy(activation) {
+    const native = validateNativeYieldAccountActivation(activation);
+    const nativeRules = native.nativeRules.map(rule => ({ ...rule, operation: 'sendEndUserOperation' }));
+    const rules = [...native.legacyRules, ...nativeRules];
+    if (native.legacyRules.length !== 5 || rules.length > 10)
+        refuseNative('NATIVE_USEROP_POLICY_RULE_LIMIT', 'Current owner, native consent, protocol scope and sponsorship authority must agree');
+    return freezeHybridValue({ body: { scope: 'project', description: NATIVE_ACCOUNT_POLICY_NAME, rules },
+        nativeActivationCommitment: nativeYieldAccountActivationCommitment(activation),
+        nativeRulesDigest: native.nativeRulesDigest, compiledFullPolicyDigest: policyRulesDigest(rules),
+        compiler: 'legacy-v2-native-enduser-userop-v1' });
+}
+//# sourceMappingURL=native-yield-userop-policy.js.map

package/dist/native-yield-userop-registration.d.ts

@@ -0,0 +1,17 @@
+/** Header authorization precedes every input parse and optional native runtime access. */
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ExecutionToolRuntime } from './execution-tools.js';
+import { type NativeUserOpAvailabilityResult } from './native-yield-userop-mcp-definition.js';
+export interface NativeYieldUserOpBinding {
+    availability(): Promise<NativeUserOpAvailabilityResult>;
+    reviewConsent(input: unknown): Promise<unknown>;
+    confirmConsent(input: unknown): Promise<unknown>;
+    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>;
+    revokeConsent(input: unknown): Promise<unknown>;
+}
+export declare function unavailableNativeYieldUserOpBinding(reason?: NonNullable<NativeUserOpAvailabilityResult['reason']>): NativeYieldUserOpBinding;
+export declare function callNativeYieldUserOp(runtime: ExecutionToolRuntime, raw: unknown, headers: Readonly<Record<string, string | string[] | undefined>> | undefined): Promise<CallToolResult>;

package/dist/native-yield-userop-registration.js

@@ -0,0 +1,76 @@
+import { accountGasFailure, AccountGasConfirmationRefusal } from './execution-account-gas-view.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 { nativeYieldUserOpAvailability } from './native-yield-userop-index.js';
+import { NATIVE_USEROP_ACTION_INPUT, NATIVE_USEROP_TOOL_RESULT, NATIVE_USEROP_AVAILABILITY_RESULT } from './native-yield-userop-mcp-definition.js';
+export function unavailableNativeYieldUserOpBinding(reason = 'SPONSOR_ACTIVATION_UNCONFIGURED') {
+    const refuse = async () => { throw new SponsoredAccountRefusal(reason); };
+    return Object.freeze({ availability: async () => NATIVE_USEROP_AVAILABILITY_RESULT.parse({ ...nativeYieldUserOpAvailability(),
+            executionEnabled: false, recoveryAvailable: false, reason }),
+        reviewConsent: refuse, confirmConsent: refuse, reviewGas: refuse, prepare: refuse, submit: refuse, read: refuse, reconcile: refuse, revokeConsent: refuse });
+}
+function success(raw) {
+    const output = NATIVE_USEROP_TOOL_RESULT.parse(raw);
+    return { content: [{ type: 'text', text: JSON.stringify(output) }], structuredContent: output };
+}
+export async function callNativeYieldUserOp(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 = NATIVE_USEROP_ACTION_INPUT.parse(raw), binding = runtime.nativeYieldUserOp ?? unavailableNativeYieldUserOpBinding();
+        if (input.action === 'availability')
+            return success(NATIVE_USEROP_AVAILABILITY_RESULT.parse(await binding.availability()));
+        const { action, ...body } = input;
+        if (action === 'submit')
+            submitId = input.operationId;
+        invoked = true;
+        const result = NATIVE_USEROP_TOOL_RESULT.parse(await binding[action](body));
+        if (action === 'reviewConsent' || action === 'confirmConsent') {
+            if (!('consent' in result) || result.consent.account.toLowerCase() !== input.input.accountProfile.address.toLowerCase() ||
+                result.consent.chainId !== input.input.accountProfile.chainId ||
+                (action === 'reviewConsent' ? result.consent.state !== 'challenge' || !result.scope
+                    : result.consent.state !== 'confirmed' || result.consent.consentId !== input.consentId ||
+                        result.consent.consentCommitment !== input.consentCommitment))
+                throw new Error('mismatched consent');
+        }
+        else if (action === 'revokeConsent') {
+            if (!('nativeConsentRevoked' in result) || result.account.toLowerCase() !== input.account.toLowerCase())
+                throw new Error('mismatched revocation');
+        }
+        else {
+            if (!('state' in result) || !('operationId' in result))
+                throw new Error('mismatched operation');
+            if (action === 'prepare') {
+                if (result.state !== 'review' || result.account.toLowerCase() !== input.input.accountProfile.address.toLowerCase() ||
+                    result.chainId !== input.input.accountProfile.chainId || result.marketId !== input.input.marketId ||
+                    result.action !== input.input.action || result.input.amount !== input.input.amount)
+                    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) {
+        if (submitId && invoked && !(error instanceof AccountGasConfirmationRefusal))
+            return success({ schemaVersion: '1', kind: 'native-yield-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
+            ? 'NATIVE_USEROP_REQUEST_INVALID' : accountGasFailure(error) ?? 'NATIVE_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 native UserOp action is unavailable or refused. Read current availability and the original operation before continuing.' }) }] };
+    }
+}
+//# sourceMappingURL=native-yield-userop-registration.js.map

package/dist/native-yield-userop-settlement.d.ts

@@ -0,0 +1,8 @@
+/** Reconcile only the canonical native UserOp. Unknown evidence never releases its shared claim. */
+import { type Hex, type PublicClient } from 'viem';
+import { type NativeYieldUserOpEnvelope, type NativeYieldUserOpSettlement } from './native-yield-userop-definition.js';
+export interface NativeYieldUserOpReceiptBinding {
+    readonly userOpHash: Hex;
+    readonly transactionHash: Hex;
+}
+export declare function readNativeYieldUserOpSettlement(rawEnvelope: NativeYieldUserOpEnvelope, binding: NativeYieldUserOpReceiptBinding, client: PublicClient, payer?: 'sponsor' | 'account'): Promise<NativeYieldUserOpSettlement>;

package/dist/native-yield-userop-settlement.js

@@ -0,0 +1,79 @@
+/** Reconcile only the canonical native UserOp. Unknown evidence never releases its shared claim. */
+import { getAddress } from 'viem';
+import { freezeHybridValue, getHybridYieldMarket } from './hybrid-yield-markets.js';
+import { NATIVE_YIELD_ERC20_ABI, NATIVE_YIELD_ROUTER_ABI } from './native-yield-definition.js';
+import { nativeYieldReceiptAmounts } from './native-yield-settlement.js';
+import { readConfirmedSponsoredReceipt, SponsoredReceiptUnconfirmedError } from './execution-sponsored-receipt.js';
+import { sponsoredOperationLogs } from './execution-sponsored-settlement.js';
+import { NATIVE_YIELD_USEROP_SETTLEMENT_SCHEMA } from './native-yield-userop-definition.js';
+import { assertNativeYieldUserOpAccountState, assertNativeYieldUserOpEnvelope } from './native-yield-userop.js';
+export async function readNativeYieldUserOpSettlement(rawEnvelope, binding, client, payer = 'sponsor') {
+    const held = (reason, status = 'held') => ({ status, reason, ...binding, releaseClaim: false, retrySafe: false });
+    try {
+        const { plan, terms } = assertNativeYieldUserOpEnvelope(rawEnvelope);
+        const confirmed = await readConfirmedSponsoredReceipt({ ...binding, account: terms.account, chainId: terms.chainId,
+            payer, entryPoint: terms.entryPoint, paymaster: payer === 'account' ? '0x0000000000000000000000000000000000000000' : terms.paymaster, maxGasCostWei: BigInt(terms.maxGasCostWei) }, client);
+        const receipt = await client.getTransactionReceipt({ hash: binding.transactionHash });
+        if (receipt.transactionHash !== confirmed.transactionHash || receipt.blockHash !== confirmed.blockHash ||
+            receipt.blockNumber.toString() !== confirmed.blockNumber)
+            return held('NATIVE_USEROP_RECEIPT_CHANGED');
+        if (receipt.logs.some((log, index) => log.removed || log.transactionHash !== receipt.transactionHash ||
+            log.blockHash !== receipt.blockHash || log.blockNumber !== receipt.blockNumber ||
+            !Number.isSafeInteger(log.logIndex) || log.logIndex === null ||
+            (index > 0 && log.logIndex <= receipt.logs[index - 1].logIndex)))
+            return held('NATIVE_USEROP_LOG_BINDING');
+        const logs = sponsoredOperationLogs(receipt, terms.entryPoint, binding.userOpHash);
+        if (logs.some(log => log.removed || log.transactionHash !== receipt.transactionHash ||
+            log.blockHash !== receipt.blockHash || log.blockNumber !== receipt.blockNumber))
+            return held('NATIVE_USEROP_LOG_BINDING');
+        const market = getHybridYieldMarket(plan.marketId);
+        const router = getAddress(terms.deployment.address), blockNumber = receipt.blockNumber;
+        await assertNativeYieldUserOpAccountState(client, terms, blockNumber, confirmed.blockHash);
+        const [inputAllowance, protocolAllowance, positionBalance, assetBalance, nonce] = await Promise.all([
+            client.readContract({ address: getAddress(plan.inputToken), abi: NATIVE_YIELD_ERC20_ABI,
+                functionName: 'allowance', args: [terms.account, router], blockNumber }),
+            client.readContract({ address: market.asset.address, abi: NATIVE_YIELD_ERC20_ABI,
+                functionName: 'allowance', args: [router, market.protocolTarget], blockNumber }),
+            client.readContract({ address: market.position.tokenAddress, abi: NATIVE_YIELD_ERC20_ABI,
+                functionName: 'balanceOf', args: [terms.account], blockNumber }),
+            client.readContract({ address: market.asset.address, abi: NATIVE_YIELD_ERC20_ABI,
+                functionName: 'balanceOf', args: [terms.account], blockNumber }),
+            client.readContract({ address: router, abi: NATIVE_YIELD_ROUTER_ABI,
+                functionName: 'nonces', args: [terms.account], blockNumber }),
+        ]);
+        // A failed atomic batch restores pre-existing allowances. Never copy swap's unconditional failed release.
+        if (inputAllowance !== 0n || protocolAllowance !== 0n)
+            return held('NATIVE_USEROP_ALLOWANCE_UNRESOLVED');
+        if (confirmed.status === 'success' ? nonce < BigInt(plan.nonce) + 1n : nonce !== BigInt(plan.nonce)) {
+            return held('NATIVE_USEROP_NONCE_UNRESOLVED');
+        }
+        const base = { ...binding, blockHash: confirmed.blockHash, blockNumber: confirmed.blockNumber,
+            owner: terms.account, marketId: plan.marketId, action: plan.action,
+            inputAllowance: '0', protocolAllowance: '0',
+            positionBalanceAtBlock: positionBalance.toString(), assetBalanceAtBlock: assetBalance.toString(),
+            routerNonceAtBlock: nonce.toString(), actualGasCostWei: confirmed.actualGasCostWei,
+            actualGasUsed: confirmed.actualGasUsed, paymaster: confirmed.paymaster,
+            releaseClaim: true, retrySafe: false };
+        const amounts = confirmed.status === 'success' ? nativeYieldReceiptAmounts(plan, { ...receipt, logs }) : undefined;
+        // For a reverted atomic batch, none of its execution logs may survive. Validation/paymaster logs
+        // are outside the protocol proof and cannot manufacture a successful native execution.
+        if (confirmed.status === 'reverted' && logs.some(log => log.address.toLowerCase() === router.toLowerCase())) {
+            return held('NATIVE_USEROP_REVERTED_PROTOCOL_LOGS');
+        }
+        if (await client.getChainId() !== terms.chainId ||
+            (await client.getBlock({ blockNumber })).hash !== confirmed.blockHash)
+            return held('NATIVE_USEROP_REORG', 'unknown');
+        return freezeHybridValue(NATIVE_YIELD_USEROP_SETTLEMENT_SCHEMA.parse(amounts
+            ? { ...base, status: 'completed', actualInput: amounts.inputAmount.toString(),
+                actualOutput: amounts.outputAmount.toString(), actualOttoFee: amounts.feeAmount.toString(),
+                feeToken: market.asset.address, protocolActionVerified: true }
+            : { ...base, status: 'reverted', protocolActionVerified: false }));
+    }
+    catch (error) {
+        // Preserve the proven receipt for the SAME sponsor activation/chain's shared breach circuit.
+        if (error instanceof SponsoredReceiptUnconfirmedError && error.code === 'SPONSOR_GAS_CAP_EXCEEDED')
+            throw error;
+        return held('NATIVE_USEROP_EVIDENCE_UNAVAILABLE', 'unknown');
+    }
+}
+//# sourceMappingURL=native-yield-userop-settlement.js.map

package/dist/native-yield-userop-simulation.d.ts

@@ -0,0 +1,18 @@
+import { type NativeYieldUserOpTerms } from './native-yield-userop-definition.js';
+import { type NativeYieldUserOpRuntime } from './native-yield-userop.js';
+export declare function simulateNativeYieldUserOp(runtime: NativeYieldUserOpRuntime, rawEnvelope: unknown, independentTerms: NativeYieldUserOpTerms): Promise<{
+    verified: import("./native-yield-userop-definition.js").VerifiedNativeYieldUserOp;
+    blockNumber: string;
+    blockHash: `0x${string}`;
+    simulatedAtMs: number;
+    calls: {
+        to: string;
+        data: string;
+        value: "0";
+    }[];
+    batchCallData: `0x${string}`;
+    minimumOutputEnforced: true;
+    simulationOnly: true;
+    includesApprovals: true;
+    provesPaymasterValidation: false;
+}>;

package/dist/native-yield-userop-simulation.js

@@ -0,0 +1,34 @@
+/** One real ordered batch eth_call against the pinned deployed delegate; no overrides or mined approvals. */
+import { encodeFunctionData } from 'viem';
+import { freezeHybridValue } from './hybrid-yield-markets.js';
+import { refuseNative } from './native-yield-definition.js';
+import { NATIVE_YIELD_USEROP_BATCH_ABI } from './native-yield-userop-definition.js';
+import { nativeYieldUserOpCalls, readNativeYieldUserOpPreflight, verifyNativeYieldUserOp } from './native-yield-userop.js';
+export async function simulateNativeYieldUserOp(runtime, rawEnvelope, independentTerms) {
+    const verified = await verifyNativeYieldUserOp(runtime, rawEnvelope, independentTerms);
+    const { envelope } = verified, { terms } = envelope;
+    const calls = nativeYieldUserOpCalls(verified);
+    const anchor = await readNativeYieldUserOpPreflight(runtime.client, envelope);
+    const data = encodeFunctionData({ abi: NATIVE_YIELD_USEROP_BATCH_ABI, functionName: 'executeBatch',
+        args: [calls.map(call => ({ target: call.to, value: 0n, data: call.data }))] });
+    // The entry point calls the upgraded OWNER, so every nested protocol call has that same owner.
+    // The supported reviewed ABI reverts the entire batch if any call fails. No balance or allowance overrides.
+    try {
+        await runtime.client.call({ account: terms.entryPoint, to: terms.account,
+            data, value: 0n, blockNumber: anchor.blockNumber });
+    }
+    catch {
+        return refuseNative('NATIVE_USEROP_SIMULATION_FAILED', 'The complete approval and native execution batch reverted');
+    }
+    const after = (runtime.nowMs ?? Date.now)();
+    if (after >= envelope.validUntilMs || anchor.blockTimestampMs > after + 5000 ||
+        after - anchor.blockTimestampMs > 60_000 ||
+        (await runtime.client.getBlock({ blockNumber: anchor.blockNumber })).hash !== anchor.blockHash) {
+        return refuseNative('NATIVE_USEROP_SIMULATION_STALE', 'The whole-batch simulation is stale or its block changed');
+    }
+    return freezeHybridValue({ verified, blockNumber: anchor.blockNumber.toString(), blockHash: anchor.blockHash,
+        simulatedAtMs: after, calls, batchCallData: data,
+        minimumOutputEnforced: true, simulationOnly: true,
+        includesApprovals: true, provesPaymasterValidation: false });
+}
+//# sourceMappingURL=native-yield-userop-simulation.js.map

package/dist/native-yield-userop.d.ts

@@ -0,0 +1,35 @@
+/** Native protocol recipes for an already-upgraded, separately authorized account. Never sends. */
+import { type Hex, type PublicClient } from 'viem';
+import { type NativeYieldRuntime } from './native-yield.js';
+import { type NativeYieldUserOpEnvelope, type NativeYieldUserOpTerms, type VerifiedNativeYieldUserOp } from './native-yield-userop-definition.js';
+export interface NativeYieldUserOpRuntime extends NativeYieldRuntime {
+    /** Server-selected client. There is no request-provided RPC or deployment override. */
+    readonly client: PublicClient;
+}
+export declare function nativeYieldUserOpConsentCommitment(terms: NativeYieldUserOpTerms): string;
+/** Durable-record integrity and exact bytes. Expiry is deliberately checked only at execution boundaries. */
+export declare function assertNativeYieldUserOpEnvelope(raw: unknown): NativeYieldUserOpEnvelope;
+/** Read the mutable implementation and owner state at the same block as its code pins. */
+export declare function assertNativeYieldUserOpAccountState(client: PublicClient, rawTerms: NativeYieldUserOpTerms, blockNumber: bigint, blockHash: Hex): Promise<void>;
+/** Fixed-block authority and allowance read; the caller re-runs it before its irreversible handoff. */
+export declare function readNativeYieldUserOpPreflight(client: PublicClient, envelope: NativeYieldUserOpEnvelope): Promise<{
+    blockNumber: bigint;
+    blockHash: `0x${string}`;
+    blockTimestampMs: number;
+}>;
+export declare function prepareNativeYieldUserOp(runtime: NativeYieldUserOpRuntime, rawInput: unknown, independentTerms: NativeYieldUserOpTerms): Promise<NativeYieldUserOpEnvelope>;
+export declare function verifyNativeYieldUserOp(runtime: NativeYieldUserOpRuntime, rawEnvelope: unknown, independentTerms: NativeYieldUserOpTerms): Promise<VerifiedNativeYieldUserOp>;
+export declare function assertVerifiedNativeYieldUserOp(value: VerifiedNativeYieldUserOp): NativeYieldUserOpEnvelope;
+/** Final read-age boundary after every blocking writer lock and immediately before provider start. */
+export declare function assertFreshVerifiedNativeYieldUserOp(value: VerifiedNativeYieldUserOp, nowMs: number): void;
+export declare function nativeYieldUserOpCalls(value: VerifiedNativeYieldUserOp): {
+    to: string;
+    data: string;
+    value: "0";
+}[];
+/** Recovery-only exact request reconstruction, including after Stop/expiry. Does not confer sending authority. */
+export declare function nativeYieldUserOpRecordedCalls(rawEnvelope: NativeYieldUserOpEnvelope): {
+    to: string;
+    data: string;
+    value: "0";
+}[];

package/dist/native-yield-userop.js

@@ -0,0 +1,156 @@
+/** Native protocol recipes for an already-upgraded, separately authorized account. Never sends. */
+import { encodeFunctionData, getAddress, keccak256, stringToHex } from 'viem';
+import { freezeHybridValue, getHybridYieldMarket, hybridYieldCommitment } from './hybrid-yield-markets.js';
+import { NATIVE_YIELD_ERC20_ABI, NATIVE_YIELD_ROUTER_ABI, NATIVE_YIELD_FEE_RECIPIENT, NATIVE_YIELD_STATE_MAX_AGE_MS, NATIVE_YIELD_TTL_SECONDS, PREPARE_NATIVE_YIELD_INPUT_SCHEMA, nativeYieldFee, refuseNative } from './native-yield-definition.js';
+import { buildNativeYieldProtocolPlan, resolveNativeYieldMarket } from './native-yield.js';
+import { assertFreshNativeYieldProtocolPlan, verifyNativeYieldProtocolPlan } from './native-yield-verify.js';
+import { NATIVE_YIELD_USEROP_ENVELOPE_SCHEMA, NATIVE_YIELD_USEROP_TERMS_SCHEMA } from './native-yield-userop-definition.js';
+import { assertSponsoredAccountProfile, SponsoredAccountProfileError } from './execution-sponsored-account-profile.js';
+const verified = new WeakMap();
+function ensure(value, code) {
+    if (!value)
+        refuseNative(code, 'The native UserOp no longer matches its separately reviewed account, protocol or sponsorship terms');
+}
+const same = (a, b) => a.toLowerCase() === b.toLowerCase();
+export function nativeYieldUserOpConsentCommitment(terms) {
+    return hybridYieldCommitment({ domain: 'otto-native-yield-userop-consent-v1', terms: NATIVE_YIELD_USEROP_TERMS_SCHEMA.parse(terms) });
+}
+/** Durable-record integrity and exact bytes. Expiry is deliberately checked only at execution boundaries. */
+export function assertNativeYieldUserOpEnvelope(raw) {
+    const envelope = NATIVE_YIELD_USEROP_ENVELOPE_SCHEMA.parse(raw);
+    const { commitment, ...core } = envelope;
+    const { plan, input, terms } = envelope;
+    const { planCommitment, ...planCore } = plan;
+    ensure(hybridYieldCommitment(core) === commitment && hybridYieldCommitment(planCore) === planCommitment, 'NATIVE_USEROP_TAMPERED');
+    const market = resolveNativeYieldMarket(input);
+    ensure(plan.marketId === market.id && plan.registryCommitment === hybridYieldCommitment(market) &&
+        plan.intentCommitment === hybridYieldCommitment(input) && terms.intentCommitment === plan.intentCommitment &&
+        same(input.accountProfile.address, terms.account) && same(plan.owner, terms.account) &&
+        plan.chainId === terms.chainId && input.accountProfile.chainId === terms.chainId &&
+        hybridYieldCommitment(plan.deployment) === hybridYieldCommitment(terms.deployment) &&
+        plan.action === input.action && plan.amount === input.amount &&
+        BigInt(plan.amount) <= BigInt(terms.maximumInputAtomic) &&
+        plan.deadline === Math.floor(plan.preparedAtMs / 1000) + NATIVE_YIELD_TTL_SECONDS &&
+        plan.snapshot.observedAtMs <= plan.preparedAtMs &&
+        plan.preparedAtMs - plan.snapshot.observedAtMs <= NATIVE_YIELD_STATE_MAX_AGE_MS &&
+        envelope.preparedAtMs === plan.preparedAtMs &&
+        envelope.validUntilMs === Math.min(plan.deadline * 1000, terms.consentExpiresAtMs) &&
+        envelope.preparedAtMs >= terms.consentCreatedAtMs && envelope.validUntilMs > envelope.preparedAtMs, 'NATIVE_USEROP_BINDING');
+    const deposit = plan.action === 'deposit';
+    const inputToken = deposit ? market.asset.address : market.position.tokenAddress;
+    const outputToken = deposit ? market.position.tokenAddress : market.asset.address;
+    const amount = BigInt(plan.amount), protocolOutput = BigInt(plan.protocolOutput);
+    const fee = nativeYieldFee(deposit ? amount : protocolOutput);
+    const expectedOutput = deposit ? protocolOutput : protocolOutput - fee;
+    const minimum = BigInt(plan.minimumOutput);
+    ensure(same(plan.inputToken, inputToken) && same(plan.outputToken, outputToken) &&
+        same(plan.fee.recipient, NATIVE_YIELD_FEE_RECIPIENT) && same(plan.fee.token, market.asset.address) &&
+        BigInt(plan.fee.amount) === fee && BigInt(plan.expectedOutput) === expectedOutput &&
+        minimum <= expectedOutput && minimum >= expectedOutput * BigInt(10_000 - input.slippage.maxBps) / 10000n &&
+        (input.slippage.minOutput === undefined || minimum >= BigInt(input.slippage.minOutput)), 'NATIVE_USEROP_RECIPE');
+    const expected = [
+        { kind: 'approve_reset', to: inputToken, value: '0', data: encodeFunctionData({
+                abi: NATIVE_YIELD_ERC20_ABI, functionName: 'approve', args: [getAddress(terms.deployment.address), 0n]
+            }) },
+        { kind: 'approve', to: inputToken, value: '0', data: encodeFunctionData({
+                abi: NATIVE_YIELD_ERC20_ABI, functionName: 'approve', args: [getAddress(terms.deployment.address), amount]
+            }) },
+        { kind: 'call', to: terms.deployment.address, value: '0', data: encodeFunctionData({
+                abi: NATIVE_YIELD_ROUTER_ABI, functionName: 'execute', args: [keccak256(stringToHex(market.id)),
+                    deposit, amount, minimum, BigInt(plan.nonce), BigInt(plan.deadline)]
+            }) },
+    ];
+    ensure(plan.steps.every((step, i) => step.kind === expected[i].kind && step.value === '0' &&
+        same(step.to, expected[i].to) && same(step.data, expected[i].data)), 'NATIVE_USEROP_RECIPE');
+    return freezeHybridValue(envelope);
+}
+/** Read the mutable implementation and owner state at the same block as its code pins. */
+export async function assertNativeYieldUserOpAccountState(client, rawTerms, blockNumber, blockHash) {
+    const terms = NATIVE_YIELD_USEROP_TERMS_SCHEMA.parse(rawTerms);
+    try {
+        await assertSponsoredAccountProfile(client, terms, blockNumber, blockHash, [{ address: getAddress(terms.deployment.address), codeHash: terms.deployment.runtimeCodeHash }]);
+    }
+    catch (error) {
+        if (error instanceof SponsoredAccountProfileError)
+            ensure(false, `NATIVE_USEROP_${error.reason}`);
+        throw error;
+    }
+}
+/** Fixed-block authority and allowance read; the caller re-runs it before its irreversible handoff. */
+export async function readNativeYieldUserOpPreflight(client, envelope) {
+    const { plan, terms } = assertNativeYieldUserOpEnvelope(envelope);
+    const market = getHybridYieldMarket(plan.marketId);
+    const block = await client.getBlock({ blockTag: 'latest' });
+    ensure(block.number !== null && block.hash, 'NATIVE_USEROP_ANCHOR');
+    const blockNumber = block.number;
+    await assertNativeYieldUserOpAccountState(client, terms, blockNumber, block.hash);
+    const [inputAllowance, protocolAllowance, nonce] = await Promise.all([
+        client.readContract({ address: getAddress(plan.inputToken), abi: NATIVE_YIELD_ERC20_ABI,
+            functionName: 'allowance', args: [terms.account, getAddress(terms.deployment.address)], blockNumber }),
+        client.readContract({ address: market.asset.address, abi: NATIVE_YIELD_ERC20_ABI,
+            functionName: 'allowance', args: [getAddress(terms.deployment.address), market.protocolTarget], blockNumber }),
+        client.readContract({ address: getAddress(terms.deployment.address), abi: NATIVE_YIELD_ROUTER_ABI,
+            functionName: 'nonces', args: [terms.account], blockNumber }),
+    ]);
+    ensure(inputAllowance === 0n && protocolAllowance === 0n, 'NATIVE_USEROP_INITIAL_ALLOWANCE');
+    ensure(nonce === BigInt(plan.nonce), 'NATIVE_USEROP_NONCE');
+    ensure((await client.getBlock({ blockNumber })).hash === block.hash, 'NATIVE_USEROP_REORG');
+    return freezeHybridValue({ blockNumber, blockHash: block.hash, blockTimestampMs: Number(block.timestamp) * 1000 });
+}
+export async function prepareNativeYieldUserOp(runtime, rawInput, independentTerms) {
+    const input = PREPARE_NATIVE_YIELD_INPUT_SCHEMA.parse(rawInput);
+    const terms = NATIVE_YIELD_USEROP_TERMS_SCHEMA.parse(independentTerms);
+    const market = resolveNativeYieldMarket(input), now = (runtime.nowMs ?? Date.now)();
+    ensure(now >= terms.consentCreatedAtMs && now < terms.consentExpiresAtMs &&
+        terms.intentCommitment === hybridYieldCommitment(input), 'NATIVE_USEROP_CONSENT');
+    ensure(runtime.deployments?.some(deployment => hybridYieldCommitment(deployment) === hybridYieldCommitment(terms.deployment)), 'NATIVE_DEPLOYMENT_REQUIRED');
+    const state = await runtime.reader.read(market, getAddress(input.accountProfile.address), input.action, BigInt(input.amount), terms.deployment);
+    const preparedAtMs = (runtime.nowMs ?? Date.now)();
+    const plan = buildNativeYieldProtocolPlan(input, market, terms.deployment, state, preparedAtMs);
+    const core = { version: 1, kind: 'native-yield-userop', input, plan, terms, preparedAtMs,
+        validUntilMs: Math.min(plan.deadline * 1000, terms.consentExpiresAtMs),
+        allowanceRecovery: 'atomic-batch-requires-zero-initial-and-final-allowances' };
+    const envelope = assertNativeYieldUserOpEnvelope({ ...core, commitment: hybridYieldCommitment(core) });
+    await verifyNativeYieldUserOp(runtime, envelope, terms);
+    return envelope;
+}
+export async function verifyNativeYieldUserOp(runtime, rawEnvelope, independentTerms) {
+    const envelope = assertNativeYieldUserOpEnvelope(rawEnvelope);
+    const terms = NATIVE_YIELD_USEROP_TERMS_SCHEMA.parse(independentTerms);
+    ensure(hybridYieldCommitment(terms) === hybridYieldCommitment(envelope.terms), 'NATIVE_USEROP_CONSENT_CHANGED');
+    const now = (runtime.nowMs ?? Date.now)();
+    ensure(now >= terms.consentCreatedAtMs && now >= envelope.preparedAtMs && now < envelope.validUntilMs, 'NATIVE_USEROP_EXPIRED');
+    const protocolPlan = await verifyNativeYieldProtocolPlan(runtime, envelope.plan, envelope.input, {
+        account: { address: terms.account, chainId: terms.chainId }, maximumInputAtomic: BigInt(terms.maximumInputAtomic),
+    });
+    const anchor = await readNativeYieldUserOpPreflight(runtime.client, envelope);
+    const monotonicAtMs = performance.now();
+    const after = (runtime.nowMs ?? Date.now)();
+    ensure(after < envelope.validUntilMs && anchor.blockTimestampMs <= after + 5000 &&
+        after - anchor.blockTimestampMs <= 60_000, 'NATIVE_USEROP_EXPIRED');
+    const result = freezeHybridValue({ envelope, verificationOnly: true });
+    verified.set(result, { protocolPlan, blockTimestampMs: anchor.blockTimestampMs,
+        checkedAtMs: after, monotonicAtMs });
+    return result;
+}
+export function assertVerifiedNativeYieldUserOp(value) {
+    ensure(value && verified.has(value) && Object.isFrozen(value), 'NATIVE_USEROP_UNVERIFIED');
+    return value.envelope;
+}
+/** Final read-age boundary after every blocking writer lock and immediately before provider start. */
+export function assertFreshVerifiedNativeYieldUserOp(value, nowMs) {
+    const envelope = assertVerifiedNativeYieldUserOp(value), facts = verified.get(value);
+    const monotonicNow = performance.now();
+    ensure(Number.isSafeInteger(nowMs) && nowMs >= facts.checkedAtMs && monotonicNow >= facts.monotonicAtMs, 'NATIVE_USEROP_EXPIRED');
+    const current = Math.max(nowMs, facts.checkedAtMs + monotonicNow - facts.monotonicAtMs);
+    ensure(current < envelope.validUntilMs && current - facts.blockTimestampMs <= NATIVE_YIELD_STATE_MAX_AGE_MS, 'NATIVE_USEROP_EXPIRED');
+    assertFreshNativeYieldProtocolPlan(facts.protocolPlan, nowMs);
+}
+export function nativeYieldUserOpCalls(value) {
+    return nativeYieldUserOpRecordedCalls(assertVerifiedNativeYieldUserOp(value));
+}
+/** Recovery-only exact request reconstruction, including after Stop/expiry. Does not confer sending authority. */
+export function nativeYieldUserOpRecordedCalls(rawEnvelope) {
+    return freezeHybridValue(assertNativeYieldUserOpEnvelope(rawEnvelope).plan.steps.map(step => ({ to: step.to.toLowerCase(), data: step.data.toLowerCase(), value: '0' })));
+}
+//# sourceMappingURL=native-yield-userop.js.map