otto-intel-mcp 0.1.2 → 0.1.4

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

@@ -0,0 +1,296 @@
+import { LP_USEROP_ACTIVATIONS, LP_USEROP_ACTIVATION_SCHEMA } from './lp-userop-definition.js';
+import { assertNativeLpCollectPolicyRelation } from './account-userop-policy-relation.js';
+/** Fresh native UserOp authority. This module has no signer, provider POST or operation journal. */
+import { getAddress } from 'viem';
+import { z } from 'zod';
+import { freezeHybridValue, getHybridYieldMarket, hybridYieldCommitment } from './hybrid-yield-markets.js';
+import { compileNativeYieldEndUserOperationPolicy } from './native-yield-userop-policy.js';
+import { policyRulesDigest } from './execution-policy-compatibility.js';
+import { SPONSORED_ACCOUNT_ACTIVATIONS, SPONSORED_ACTIVATION_SCHEMA, sponsoredChainTerms, sponsoredDigest } from './execution-sponsored-definition.js';
+import { NATIVE_ACCOUNT_AUTHORITY_SCHEMA, NATIVE_ACCOUNT_RULESET, NATIVE_ACCOUNT_SCOPES, NATIVE_YIELD_ACCOUNT_ACTIVATIONS } from './native-yield-account-definition.js';
+import { assertNativeDepositWithinOwnerUsdCap, deriveExactApprovedNativeMarketLimits, resolveNativeYieldAccountActivation } from './native-yield-account-policy.js';
+import { assertCurrentNativeYieldConsent, confirmNativeYieldConsent, createNativeYieldConsent, readConfirmedNativeYieldConsent } from './native-yield-consent-store.js';
+import { NATIVE_YIELD_STATE_MAX_AGE_MS, PREPARE_NATIVE_YIELD_INPUT_SCHEMA, refuseNative } from './native-yield-definition.js';
+import { resolveNativeYieldMarket } from './native-yield.js';
+import { NATIVE_YIELD_USEROP_CONSENT_TTL_MS, NATIVE_YIELD_USEROP_RULESET, NATIVE_YIELD_USEROP_TERMS_SCHEMA } from './native-yield-userop-definition.js';
+import { assertNativeYieldUserOpAccountState } from './native-yield-userop.js';
+const digest = z.string().regex(/^[0-9a-f]{64}$/).refine(value => !/^0+$/.test(value));
+const commitment = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const address = z.string().regex(/^0x[0-9a-fA-F]{40}$/).transform(value => getAddress(value));
+const codeHash = z.string().regex(/^0x[0-9a-fA-F]{64}$/);
+const RELATION_SCHEMA = z.object({
+    nativeActivationCommitment: commitment, nativeRulesDigest: digest, compiledFullPolicyDigest: digest,
+    relationReviewEvidenceDigest: digest, compiler: z.literal('legacy-v2-native-enduser-userop-v1'),
+}).strict();
+const PROFILE_SCHEMA = z.object({
+    implementation: address, implementationCodeHash: codeHash,
+    delegateBatchAbi: z.literal('coinbase-executeBatch-v1'), delegateBatchReviewDigest: digest,
+    entryPointVersion: z.literal('0.6'), ownerProfile: z.object({
+        kind: z.literal('sole-eoa-owner'), nextOwnerIndex: z.literal('1'), ownerCount: z.literal('1'),
+        requireAccountAsOwner: z.literal(true), spendPermissionsEnabled: z.literal(false),
+    }).strict(),
+}).strict();
+export { compileNativeYieldEndUserOperationPolicy } from './native-yield-userop-policy.js';
+const CONSENT_REF_SCHEMA = z.object({
+    consentId: z.string().regex(/^nc_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/),
+    generation: z.number().int().positive().safe(), consentCommitment: commitment,
+}).strict();
+export const NATIVE_YIELD_USEROP_REVIEW_RECORD_SCHEMA = z.object({ input: PREPARE_NATIVE_YIELD_INPUT_SCHEMA,
+    terms: NATIVE_YIELD_USEROP_TERMS_SCHEMA, consent: CONSENT_REF_SCHEMA }).strict();
+const brand = Symbol('native-userop-authority');
+function ensure(value, code) {
+    if (!value)
+        refuseNative(code, 'Current owner, native consent, protocol scope and sponsorship authority must agree');
+}
+function equal(left, right) { return hybridYieldCommitment(left) === hybridYieldCommitment(right); }
+function sourceIdentity(source) {
+    return { nativeActivation: source.nativeActivation, sponsorActivation: source.sponsorActivation,
+        chainTerms: source.chainTerms, profile: source.profile, relation: source.relation };
+}
+function consentRef(consent) {
+    return { consentId: consent.consentId, generation: consent.generation, consentCommitment: consent.consentCommitment };
+}
+export class NativeYieldUserOpAuthorityIssuer {
+    native;
+    sponsor;
+    db;
+    issued = new WeakMap();
+    minted = new WeakSet();
+    nativeActivations;
+    sponsorActivations;
+    lpActivations;
+    constructor(native, sponsor, db, 
+    /** Internal source fixtures only. The production constructor uses the two empty reviewed arrays. */
+    fixtures) {
+        this.native = native;
+        this.sponsor = sponsor;
+        this.db = db;
+        this.nativeActivations = fixtures?.nativeActivations ?? NATIVE_YIELD_ACCOUNT_ACTIVATIONS;
+        this.sponsorActivations = fixtures?.sponsoredActivations ?? SPONSORED_ACCOUNT_ACTIVATIONS;
+        this.lpActivations = fixtures?.lpActivations ?? LP_USEROP_ACTIVATIONS;
+    }
+    now() {
+        const now = this.sponsor.now();
+        ensure(Number.isSafeInteger(now) && now > 0, 'NATIVE_USEROP_CLOCK');
+        return now;
+    }
+    sources(input) {
+        const market = resolveNativeYieldMarket(input), chainId = market.chainId;
+        ensure(this.nativeActivations.length === 1, 'NATIVE_USEROP_NATIVE_ACTIVATION_REQUIRED');
+        const nativeActivation = resolveNativeYieldAccountActivation(chainId, this.nativeActivations);
+        const limits = deriveExactApprovedNativeMarketLimits(nativeActivation, { chainId,
+            marketId: input.marketId, registryCommitment: input.registryCommitment, action: input.action });
+        // The shared sponsored rail admits one activation globally, not one per requested chain.
+        ensure(this.sponsorActivations.length === 1, 'NATIVE_USEROP_SPONSOR_ACTIVATION_REQUIRED');
+        const sponsorActivation = SPONSORED_ACTIVATION_SCHEMA.parse(this.sponsorActivations[0]);
+        ensure(sponsorActivation.chains.some(chain => chain.chainId === chainId), 'NATIVE_USEROP_SPONSOR_CHAIN_REQUIRED');
+        const chainTerms = sponsoredChainTerms(sponsorActivation, chainId);
+        const profile = PROFILE_SCHEMA.parse(chainTerms.nativeYieldUserOpProfile);
+        const relation = RELATION_SCHEMA.parse(sponsorActivation.nativeYieldUserOpPolicyRelation);
+        const compiled = compileNativeYieldEndUserOperationPolicy(nativeActivation);
+        ensure(sponsorActivation.mode === 'enabled' &&
+            sponsorActivation.projectId === this.sponsor.projectId && sponsorActivation.approvedAtMs <= this.now() &&
+            sponsorActivation.expiresAtMs > this.now() && sponsorActivation.policyId === nativeActivation.policyId &&
+            sponsorActivation.policyName === nativeActivation.policyName &&
+            relation.compiler === compiled.compiler && relation.nativeActivationCommitment === compiled.nativeActivationCommitment &&
+            relation.nativeRulesDigest === compiled.nativeRulesDigest &&
+            relation.compiledFullPolicyDigest === compiled.compiledFullPolicyDigest, 'NATIVE_USEROP_POLICY_RELATION');
+        if (sponsorActivation.lpUserOpPolicyRelation) {
+            ensure(this.lpActivations.length === 1, 'NATIVE_USEROP_LP_ACTIVATION_REQUIRED');
+            const lp = LP_USEROP_ACTIVATION_SCHEMA.parse(this.lpActivations[0]);
+            ensure(lp.approvedAtMs <= this.now() && lp.expiresAtMs > this.now(), 'NATIVE_USEROP_LP_ACTIVATION_EXPIRED');
+            assertNativeLpCollectPolicyRelation(nativeActivation, sponsorActivation, lp);
+        }
+        else
+            ensure(sponsorActivation.policyRulesDigest === compiled.compiledFullPolicyDigest, 'NATIVE_USEROP_POLICY_RELATION');
+        return freezeHybridValue({ nativeActivation, sponsorActivation, chainTerms, profile, relation, limits });
+    }
+    consentAuthority(source, sponsor) {
+        const activation = source.nativeActivation;
+        return freezeHybridValue(NATIVE_ACCOUNT_AUTHORITY_SCHEMA.parse({ userId: sponsor.userId, account: sponsor.account,
+            mintKey: sponsor.mintKey, grantExpiresAt: sponsor.grantExpiresAt, revokeGeneration: sponsor.revokeGeneration,
+            capRulesetVersion: sponsor.capVersion, perSwapCapUsd: sponsor.perSwapCapUsd,
+            policyId: source.sponsorActivation.policyId, policyName: source.sponsorActivation.policyName,
+            policyDigest: source.sponsorActivation.policyRulesDigest, legacyRulesDigest: activation.legacyRulesDigest,
+            nativeRulesDigest: activation.nativeRulesDigest, activationCommitment: source.relation.nativeActivationCommitment,
+            scopeCommitment: hybridYieldCommitment({ domain: 'native-yield-enduser-userop-scope-v1',
+                ruleset: NATIVE_YIELD_USEROP_RULESET, scopes: NATIVE_ACCOUNT_SCOPES,
+                nativeActivationCommitment: source.relation.nativeActivationCommitment,
+                sponsoredActivationDigest: sponsoredDigest(source.sponsorActivation),
+                relation: source.relation, chainTerms: source.chainTerms }),
+            ruleset: NATIVE_ACCOUNT_RULESET, scopes: [...NATIVE_ACCOUNT_SCOPES] }));
+    }
+    assertValuation(input, facts) {
+        // A private valuation input, never returned or passed to an EOA sender. The old helper binds its
+        // limits to the original native manifest; actual current policy authority stays the full UserOp policy.
+        const valuationOnly = { ...facts.nativeAuthority, policyDigest: facts.nativeActivation.policyDigest };
+        const value = assertNativeDepositWithinOwnerUsdCap({ amountAtomic: BigInt(input.amount), authority: valuationOnly,
+            limits: facts.limits, priceObservation: facts.price, nowMs: this.now() });
+        ensure(value.valuedUsdCents === undefined ||
+            value.valuedUsdCents <= BigInt(facts.sponsorActivation.maxSwapUsdc) * 100n, 'NATIVE_USEROP_ABOVE_SPONSOR_CAP');
+    }
+    window(facts, prior) {
+        const consentCreatedAtMs = prior?.consentCreatedAtMs ?? this.now();
+        const consentExpiresAtMs = Math.min(consentCreatedAtMs + NATIVE_YIELD_USEROP_CONSENT_TTL_MS, facts.sponsorActivation.expiresAtMs, Date.parse(facts.nativeAuthority.grantExpiresAt), Date.parse(facts.sponsorAuthority.grantExpiresAt));
+        ensure(consentCreatedAtMs <= this.now() && this.now() < consentExpiresAtMs &&
+            (!prior || prior.consentExpiresAtMs === consentExpiresAtMs), 'NATIVE_USEROP_AUTHORITY_EXPIRED');
+        return { consentCreatedAtMs, consentExpiresAtMs };
+    }
+    derivedTerms(input, facts, window, consent) {
+        const { sponsorActivation: activation, chainTerms: chain, profile } = facts;
+        return freezeHybridValue(NATIVE_YIELD_USEROP_TERMS_SCHEMA.parse({
+            version: 1, ruleset: NATIVE_YIELD_USEROP_RULESET, userId: facts.nativeAuthority.userId,
+            account: facts.nativeAuthority.account, chainId: input.accountProfile.chainId,
+            authorityDigest: sponsoredDigest({ domain: 'native-yield-userop-current-authority-v1',
+                nativeAuthority: facts.nativeAuthority, sponsorAuthority: facts.sponsorAuthority,
+                consent: consent ? consentRef(consent) : null, intentCommitment: hybridYieldCommitment(input), ...window }),
+            nativeActivationCommitment: facts.relation.nativeActivationCommitment,
+            sponsoredActivationId: activation.id, sponsoredActivationDigest: sponsoredDigest(activation),
+            projectId: activation.projectId, policyId: activation.policyId, policyRulesDigest: activation.policyRulesDigest,
+            providerEnforcementEvidenceDigest: activation.providerEnforcementEvidenceDigest,
+            providerEndpoint: 'cdp-end-user-smart-account-send-v1', deployment: facts.limits.deployment,
+            delegate: chain.delegate, delegateCodeHash: chain.delegateCodeHash,
+            implementation: profile.implementation, implementationCodeHash: profile.implementationCodeHash,
+            delegateBatchAbi: profile.delegateBatchAbi, delegateBatchReviewDigest: profile.delegateBatchReviewDigest,
+            entryPoint: chain.entryPoint, entryPointCodeHash: chain.entryPointCodeHash,
+            entryPointVersion: profile.entryPointVersion, ownerProfile: { kind: 'sole-eoa-owner', nextOwnerIndex: '1',
+                ownerCount: '1', ownerAtIndex0: '0x' + '0'.repeat(24) + facts.nativeAuthority.account.slice(2).toLowerCase(),
+                spendPermissionsEnabled: false },
+            paymaster: chain.paymaster, paymasterCodeHash: chain.paymasterCodeHash,
+            sponsorshipPolicyId: chain.sponsorshipPolicyId, maxGasCostWei: chain.maxGasCostWei,
+            maxUserGasCostWei: chain.maxUserGasCostWei, maxTotalGasCostWei: chain.maxTotalGasCostWei,
+            maximumInputAtomic: facts.limits.maximumInputAtomic.toString(), intentCommitment: hybridYieldCommitment(input),
+            ...window, initialInputAllowance: '0', initialProtocolAllowance: '0',
+            execution: 'atomic-approve-reset-approve-execute'
+        }));
+    }
+    async facts(accessToken, input) {
+        const source = this.sources(input), market = source.limits.market, account = getAddress(input.accountProfile.address);
+        const output = input.action === 'deposit' ? market.position.tokenAddress : market.asset.address;
+        const sponsorAuthority = await this.sponsor.authority(accessToken, account, market.chainId, source.sponsorActivation, getAddress(output), 'native-yield-userop');
+        const nativeAuthority = this.consentAuthority(source, sponsorAuthority);
+        const facts = { ...source, sponsorAuthority, nativeAuthority, price: await this.native.price(source.limits) };
+        this.assertValuation(input, facts);
+        // The profile-only check mints no consent or authority; these provisional terms never escape.
+        const proofTerms = this.derivedTerms(input, facts, this.window(facts));
+        const client = this.sponsor.client(market.chainId), block = await client.getBlock({ blockTag: 'latest' });
+        const timestampMs = Number(block.timestamp) * 1000;
+        ensure(block.number !== null && block.hash && Number.isSafeInteger(timestampMs) && timestampMs > 0 &&
+            timestampMs <= this.now() + 5000 && this.now() - timestampMs <= NATIVE_YIELD_STATE_MAX_AGE_MS, 'NATIVE_USEROP_ACCOUNT_ANCHOR');
+        await assertNativeYieldUserOpAccountState(client, proofTerms, block.number, block.hash);
+        const [who, grant, policies] = await Promise.all([
+            this.sponsor.identity(accessToken, account),
+            this.sponsor.cdp.endUser.getDelegationForEndUserAccount({ userId: nativeAuthority.userId, address: account }),
+            this.sponsor.cdp.policies.listPolicies({ scope: 'project' }),
+            this.native.assertCurrentSession(accessToken, nativeAuthority),
+        ]);
+        const smart = (who.current.evmSmartAccountObjects ?? []).filter(value => getAddress(value.address) === account);
+        const project = (policies.policies ?? []).filter(value => value.scope === 'project');
+        ensure(who.userId === nativeAuthority.userId && smart.length === 1 && smart[0].ownerAddresses.length === 1 &&
+            getAddress(smart[0].ownerAddresses[0]) === account && Date.parse(grant.expiresAt) === Date.parse(nativeAuthority.grantExpiresAt) &&
+            Date.parse(grant.expiresAt) > this.now() && project.length === 1 && project[0].id === source.sponsorActivation.policyId &&
+            project[0].description === source.sponsorActivation.policyName &&
+            policyRulesDigest(project[0].rules) === source.sponsorActivation.policyRulesDigest, 'NATIVE_USEROP_CURRENT_AUTHORITY_CHANGED');
+        await this.sponsor.assertCurrentCap(sponsorAuthority);
+        ensure(equal(sourceIdentity(this.sources(input)), sourceIdentity(source)), 'NATIVE_USEROP_SOURCE_CHANGED');
+        this.assertValuation(input, facts);
+        return freezeHybridValue(facts);
+    }
+    /** Fresh source-scope projection for human consent review, before an operation authority exists. */
+    async reviewConsent(accessToken, rawInput) {
+        const input = PREPARE_NATIVE_YIELD_INPUT_SCHEMA.parse(rawInput), facts = await this.facts(accessToken, input);
+        const marketLimits = facts.nativeActivation.marketRules.flatMap(rule => {
+            const market = getHybridYieldMarket(rule.marketId);
+            if (market.chainId !== input.accountProfile.chainId ||
+                (facts.nativeActivation.mode === 'recovery-only' && rule.action === 'deposit'))
+                return [];
+            return [{ marketId: rule.marketId, action: rule.action,
+                    inputToken: rule.action === 'deposit' ? market.asset.address : market.position.tokenAddress,
+                    maximumInputAtomic: rule.maximumInputAtomic }];
+        });
+        const scope = freezeHybridValue({ account: facts.nativeAuthority.account, chainId: input.accountProfile.chainId,
+            scopes: [...NATIVE_ACCOUNT_SCOPES], marketLimits,
+            perDepositCapUsd: Math.min(facts.nativeAuthority.perSwapCapUsd, facts.sponsorActivation.maxSwapUsdc),
+            maximumGasCostWei: facts.chainTerms.maxGasCostWei, maximumUserGasCostWei: facts.chainTerms.maxUserGasCostWei,
+            maximumActivationGasCostWei: facts.chainTerms.maxTotalGasCostWei,
+            expiresAtMs: Math.min(Date.parse(facts.nativeAuthority.grantExpiresAt), facts.sponsorActivation.expiresAtMs),
+            requiresSeparateOperationReview: true });
+        const consent = createNativeYieldConsent(this.db, facts.nativeAuthority, this.now());
+        return { consent, scope };
+    }
+    async createConsent(accessToken, rawInput) {
+        return (await this.reviewConsent(accessToken, rawInput)).consent;
+    }
+    async confirmConsent(accessToken, rawInput, confirmation) {
+        const input = PREPARE_NATIVE_YIELD_INPUT_SCHEMA.parse(rawInput), facts = await this.facts(accessToken, input);
+        return confirmNativeYieldConsent(this.db, { ...confirmation, userId: facts.nativeAuthority.userId }, facts.nativeAuthority, this.now());
+    }
+    async issue(accessToken, rawInput, previous) {
+        const input = freezeHybridValue(PREPARE_NATIVE_YIELD_INPUT_SCHEMA.parse(rawInput));
+        const facts = await this.facts(accessToken, input);
+        const consent = readConfirmedNativeYieldConsent(this.db, facts.nativeAuthority.userId, facts.nativeAuthority.account, this.now());
+        ensure(consent, 'NATIVE_USEROP_NATIVE_CONSENT_REQUIRED');
+        const terms = this.derivedTerms(input, facts, this.window(facts, previous?.terms), consent);
+        const review = freezeHybridValue(NATIVE_YIELD_USEROP_REVIEW_RECORD_SCHEMA.parse({ input, terms, consent: consentRef(consent) }));
+        ensure(!previous || equal(review, previous), 'NATIVE_USEROP_REVIEW_AUTHORITY_CHANGED');
+        const token = Object.freeze({ [brand]: true });
+        // Last synchronous authority read, including when the caller already stamped its shared journal.
+        assertCurrentNativeYieldConsent(this.db, consent, facts.nativeAuthority, this.now());
+        this.minted.add(token);
+        this.issued.set(token, { facts, consent, review });
+        return token;
+    }
+    mint(accessToken, rawInput) {
+        return this.issue(accessToken, rawInput);
+    }
+    read(authority) {
+        ensure(authority && this.minted.has(authority), 'NATIVE_USEROP_OPAQUE_AUTHORITY_REQUIRED');
+        const issued = this.issued.get(authority);
+        ensure(issued, 'NATIVE_USEROP_OPAQUE_AUTHORITY_REQUIRED');
+        return issued;
+    }
+    /** Re-read after the shared journal stamp and after transport auth, immediately before POST. */
+    async refresh(accessToken, authority) {
+        const previous = this.read(authority).review;
+        return this.issue(accessToken, previous.input, previous);
+    }
+    /** Internal journal recovery only. Never route raw MCP terms into this method. */
+    async restoreFromTrustedReview(accessToken, rawStoredReview) {
+        const review = NATIVE_YIELD_USEROP_REVIEW_RECORD_SCHEMA.parse(rawStoredReview);
+        return this.issue(accessToken, review.input, review);
+    }
+    /** Must also run synchronously inside/after the caller's shared-journal stamp; performs no await. */
+    assertConsent(authority) {
+        const issued = this.read(authority), { facts, consent, review } = issued;
+        this.window(facts, review.terms);
+        ensure(equal(sourceIdentity(this.sources(review.input)), sourceIdentity(facts)), 'NATIVE_USEROP_SOURCE_CHANGED');
+        this.assertValuation(review.input, facts);
+        assertCurrentNativeYieldConsent(this.db, consent, facts.nativeAuthority, this.now());
+    }
+    /** Hold the current cap writer lock through the synchronous provider request invocation. */
+    withCurrentCap(authority, start) {
+        this.assertConsent(authority);
+        return this.sponsor.withCurrentCap(this.read(authority).facts.sponsorAuthority, () => {
+            // Waiting for the cap writer lock must not outlive the reviewed authority or price observation.
+            this.assertConsent(authority);
+            return start();
+        });
+    }
+    terms(authority) {
+        this.assertConsent(authority);
+        return this.read(authority).review.terms;
+    }
+    reviewRecord(authority) {
+        this.assertConsent(authority);
+        return this.read(authority).review;
+    }
+    sponsorship(authority) {
+        this.assertConsent(authority);
+        return this.read(authority).facts.sponsorAuthority;
+    }
+    activation(authority) {
+        this.assertConsent(authority);
+        return this.read(authority).facts.sponsorActivation;
+    }
+}
+//# sourceMappingURL=native-yield-userop-authority.js.map

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

@@ -0,0 +1,331 @@
+import { z } from 'zod';
+export declare const NATIVE_YIELD_USEROP_RULESET: "native-yield-userop-v1";
+export declare const NATIVE_YIELD_USEROP_CONFIRMATION: "I reviewed this native yield action and sponsored atomic batch";
+export declare const NATIVE_YIELD_USEROP_ACCOUNT_GAS_CONFIRMATION: "I reviewed this native yield action and account-paid atomic batch";
+export declare const NATIVE_YIELD_USEROP_CONSENT_TTL_MS: number;
+/** First reviewed contract family only. A new proxy/implementation/profile requires a separate source review. */
+export declare const NATIVE_YIELD_USEROP_PROXY: `0x${string}`;
+export declare const NATIVE_YIELD_USEROP_IMPLEMENTATION: `0x${string}`;
+export declare const NATIVE_YIELD_USEROP_ENTRY_POINT: `0x${string}`;
+export declare const NATIVE_YIELD_USEROP_IMPLEMENTATION_SLOT: `0x${string}`;
+export declare const NATIVE_YIELD_USEROP_ACCOUNT_ABI: readonly [{
+    readonly name: "nextOwnerIndex";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "ownerCount";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "ownerAtIndex";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "index";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bytes";
+    }];
+}, {
+    readonly name: "isOwnerAddress";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "entryPoint";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}];
+/** Supported only when exact delegate bytecode and atomic semantics have been independently reviewed. */
+export declare const NATIVE_YIELD_USEROP_BATCH_ABI: readonly [{
+    readonly name: "executeBatch";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "target";
+        }, {
+            readonly type: "uint256";
+            readonly name: "value";
+        }, {
+            readonly type: "bytes";
+            readonly name: "data";
+        }];
+        readonly name: "calls";
+    }];
+    readonly outputs: readonly [];
+}];
+export declare const NATIVE_YIELD_USEROP_TERMS_SCHEMA: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    ruleset: z.ZodLiteral<"native-yield-userop-v1">;
+    userId: z.ZodString;
+    account: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    chainId: z.ZodUnion<readonly [z.ZodLiteral<8453>, z.ZodLiteral<42161>]>;
+    authorityDigest: z.ZodString;
+    nativeActivationCommitment: z.ZodString;
+    sponsoredActivationId: z.ZodString;
+    sponsoredActivationDigest: z.ZodString;
+    projectId: z.ZodString;
+    policyId: z.ZodString;
+    policyRulesDigest: z.ZodString;
+    providerEnforcementEvidenceDigest: z.ZodString;
+    providerEndpoint: z.ZodLiteral<"cdp-end-user-smart-account-send-v1">;
+    deployment: z.ZodObject<{
+        chainId: z.ZodUnion<readonly [z.ZodLiteral<8453>, z.ZodLiteral<42161>]>;
+        address: z.ZodString;
+        runtimeCodeHash: z.ZodString;
+        version: z.ZodLiteral<"native-yield-router-v1">;
+        reviewId: z.ZodString;
+    }, z.core.$strict>;
+    delegate: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    delegateCodeHash: z.ZodString;
+    implementation: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    implementationCodeHash: z.ZodString;
+    delegateBatchAbi: z.ZodLiteral<"coinbase-executeBatch-v1">;
+    delegateBatchReviewDigest: z.ZodString;
+    entryPoint: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    entryPointCodeHash: z.ZodString;
+    entryPointVersion: z.ZodLiteral<"0.6">;
+    ownerProfile: z.ZodObject<{
+        kind: z.ZodLiteral<"sole-eoa-owner">;
+        nextOwnerIndex: z.ZodLiteral<"1">;
+        ownerCount: z.ZodLiteral<"1">;
+        ownerAtIndex0: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        spendPermissionsEnabled: z.ZodLiteral<false>;
+    }, z.core.$strict>;
+    paymaster: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    paymasterCodeHash: z.ZodString;
+    sponsorshipPolicyId: z.ZodString;
+    maxGasCostWei: z.ZodString;
+    maxUserGasCostWei: z.ZodString;
+    maxTotalGasCostWei: z.ZodString;
+    maximumInputAtomic: z.ZodString;
+    intentCommitment: z.ZodString;
+    consentCreatedAtMs: z.ZodNumber;
+    consentExpiresAtMs: z.ZodNumber;
+    initialInputAllowance: z.ZodLiteral<"0">;
+    initialProtocolAllowance: z.ZodLiteral<"0">;
+    execution: z.ZodLiteral<"atomic-approve-reset-approve-execute">;
+}, z.core.$strict>;
+export type NativeYieldUserOpTerms = z.infer<typeof NATIVE_YIELD_USEROP_TERMS_SCHEMA>;
+export declare const NATIVE_YIELD_USEROP_ENVELOPE_SCHEMA: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"native-yield-userop">;
+    input: z.ZodObject<{
+        accountProfile: z.ZodObject<{
+            kind: z.ZodLiteral<"eoa">;
+            address: z.ZodString;
+            chainId: z.ZodUnion<readonly [z.ZodLiteral<8453>, z.ZodLiteral<42161>]>;
+        }, z.core.$strict>;
+        marketId: z.ZodString;
+        registryCommitment: z.ZodString;
+        action: z.ZodEnum<{
+            deposit: "deposit";
+            withdraw: "withdraw";
+        }>;
+        amount: z.ZodString;
+        slippage: z.ZodObject<{
+            maxBps: z.ZodNumber;
+            minOutput: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        clientRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    plan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        kind: z.ZodLiteral<"native-yield-plan">;
+        transport: z.ZodLiteral<"native-protocol">;
+        marketId: z.ZodString;
+        registryCommitment: z.ZodString;
+        owner: z.ZodString;
+        chainId: z.ZodUnion<readonly [z.ZodLiteral<8453>, z.ZodLiteral<42161>]>;
+        action: z.ZodEnum<{
+            deposit: "deposit";
+            withdraw: "withdraw";
+        }>;
+        amount: z.ZodString;
+        inputToken: z.ZodString;
+        outputToken: z.ZodString;
+        expectedOutput: z.ZodString;
+        minimumOutput: z.ZodString;
+        protocolOutput: z.ZodString;
+        fee: z.ZodObject<{
+            bps: z.ZodLiteral<10>;
+            recipient: z.ZodString;
+            token: z.ZodString;
+            amount: z.ZodString;
+            version: z.ZodLiteral<"native-yield-10bps-floor-v1">;
+            rounding: z.ZodLiteral<"floor">;
+        }, z.core.$strict>;
+        nonce: z.ZodString;
+        deadline: z.ZodNumber;
+        preparedAtMs: z.ZodNumber;
+        snapshot: z.ZodObject<{
+            blockNumber: z.ZodString;
+            blockHash: z.ZodString;
+            observedAtMs: z.ZodNumber;
+        }, z.core.$strict>;
+        deployment: z.ZodObject<{
+            chainId: z.ZodUnion<readonly [z.ZodLiteral<8453>, z.ZodLiteral<42161>]>;
+            address: z.ZodString;
+            runtimeCodeHash: z.ZodString;
+            version: z.ZodLiteral<"native-yield-router-v1">;
+            reviewId: z.ZodString;
+        }, z.core.$strict>;
+        steps: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                approve: "approve";
+                approve_reset: "approve_reset";
+                call: "call";
+            }>;
+            to: z.ZodString;
+            value: z.ZodLiteral<"0">;
+            data: z.ZodString;
+        }, z.core.$strict>>;
+        authorization: z.ZodLiteral<"requires-separate-account-authority">;
+        allowanceRecovery: z.ZodLiteral<"approval-is-separate-and-may-remain-after-failure">;
+        intentCommitment: z.ZodString;
+        planCommitment: z.ZodString;
+    }, z.core.$strict>;
+    terms: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        ruleset: z.ZodLiteral<"native-yield-userop-v1">;
+        userId: z.ZodString;
+        account: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        chainId: z.ZodUnion<readonly [z.ZodLiteral<8453>, z.ZodLiteral<42161>]>;
+        authorityDigest: z.ZodString;
+        nativeActivationCommitment: z.ZodString;
+        sponsoredActivationId: z.ZodString;
+        sponsoredActivationDigest: z.ZodString;
+        projectId: z.ZodString;
+        policyId: z.ZodString;
+        policyRulesDigest: z.ZodString;
+        providerEnforcementEvidenceDigest: z.ZodString;
+        providerEndpoint: z.ZodLiteral<"cdp-end-user-smart-account-send-v1">;
+        deployment: z.ZodObject<{
+            chainId: z.ZodUnion<readonly [z.ZodLiteral<8453>, z.ZodLiteral<42161>]>;
+            address: z.ZodString;
+            runtimeCodeHash: z.ZodString;
+            version: z.ZodLiteral<"native-yield-router-v1">;
+            reviewId: z.ZodString;
+        }, z.core.$strict>;
+        delegate: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        delegateCodeHash: z.ZodString;
+        implementation: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        implementationCodeHash: z.ZodString;
+        delegateBatchAbi: z.ZodLiteral<"coinbase-executeBatch-v1">;
+        delegateBatchReviewDigest: z.ZodString;
+        entryPoint: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        entryPointCodeHash: z.ZodString;
+        entryPointVersion: z.ZodLiteral<"0.6">;
+        ownerProfile: z.ZodObject<{
+            kind: z.ZodLiteral<"sole-eoa-owner">;
+            nextOwnerIndex: z.ZodLiteral<"1">;
+            ownerCount: z.ZodLiteral<"1">;
+            ownerAtIndex0: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            spendPermissionsEnabled: z.ZodLiteral<false>;
+        }, z.core.$strict>;
+        paymaster: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+        paymasterCodeHash: z.ZodString;
+        sponsorshipPolicyId: z.ZodString;
+        maxGasCostWei: z.ZodString;
+        maxUserGasCostWei: z.ZodString;
+        maxTotalGasCostWei: z.ZodString;
+        maximumInputAtomic: z.ZodString;
+        intentCommitment: z.ZodString;
+        consentCreatedAtMs: z.ZodNumber;
+        consentExpiresAtMs: z.ZodNumber;
+        initialInputAllowance: z.ZodLiteral<"0">;
+        initialProtocolAllowance: z.ZodLiteral<"0">;
+        execution: z.ZodLiteral<"atomic-approve-reset-approve-execute">;
+    }, z.core.$strict>;
+    preparedAtMs: z.ZodNumber;
+    validUntilMs: z.ZodNumber;
+    allowanceRecovery: z.ZodLiteral<"atomic-batch-requires-zero-initial-and-final-allowances">;
+    commitment: z.ZodString;
+}, z.core.$strict>;
+export type NativeYieldUserOpEnvelope = z.infer<typeof NATIVE_YIELD_USEROP_ENVELOPE_SCHEMA>;
+export interface VerifiedNativeYieldUserOp {
+    readonly envelope: NativeYieldUserOpEnvelope;
+    readonly verificationOnly: true;
+}
+export declare const NATIVE_YIELD_USEROP_SETTLEMENT_SCHEMA: z.ZodUnion<readonly [z.ZodObject<{
+    status: z.ZodLiteral<"completed">;
+    actualInput: z.ZodString;
+    actualOutput: z.ZodString;
+    actualOttoFee: z.ZodString;
+    feeToken: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    protocolActionVerified: z.ZodLiteral<true>;
+    transactionHash: z.ZodString;
+    userOpHash: z.ZodString;
+    blockHash: z.ZodString;
+    blockNumber: z.ZodString;
+    owner: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    marketId: z.ZodString;
+    action: z.ZodEnum<{
+        deposit: "deposit";
+        withdraw: "withdraw";
+    }>;
+    inputAllowance: z.ZodLiteral<"0">;
+    protocolAllowance: z.ZodLiteral<"0">;
+    positionBalanceAtBlock: z.ZodString;
+    assetBalanceAtBlock: z.ZodString;
+    routerNonceAtBlock: z.ZodString;
+    actualGasCostWei: z.ZodString;
+    actualGasUsed: z.ZodString;
+    paymaster: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    releaseClaim: z.ZodLiteral<true>;
+    retrySafe: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"reverted">;
+    protocolActionVerified: z.ZodLiteral<false>;
+    transactionHash: z.ZodString;
+    userOpHash: z.ZodString;
+    blockHash: z.ZodString;
+    blockNumber: z.ZodString;
+    owner: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    marketId: z.ZodString;
+    action: z.ZodEnum<{
+        deposit: "deposit";
+        withdraw: "withdraw";
+    }>;
+    inputAllowance: z.ZodLiteral<"0">;
+    protocolAllowance: z.ZodLiteral<"0">;
+    positionBalanceAtBlock: z.ZodString;
+    assetBalanceAtBlock: z.ZodString;
+    routerNonceAtBlock: z.ZodString;
+    actualGasCostWei: z.ZodString;
+    actualGasUsed: z.ZodString;
+    paymaster: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    releaseClaim: z.ZodLiteral<true>;
+    retrySafe: z.ZodLiteral<false>;
+}, z.core.$strict>]>;
+export type NativeYieldUserOpSettled = z.infer<typeof NATIVE_YIELD_USEROP_SETTLEMENT_SCHEMA>;
+export type NativeYieldUserOpSettlement = NativeYieldUserOpSettled | {
+    readonly status: 'unknown' | 'held';
+    readonly reason: string;
+    readonly transactionHash: `0x${string}`;
+    readonly userOpHash: `0x${string}`;
+    readonly releaseClaim: false;
+    readonly retrySafe: false;
+};