otto-intel-mcp 0.1.2 → 0.1.4

package/dist/native-yield-consent-store.js

@@ -0,0 +1,317 @@
+import { NATIVE_CONSENT_SCHEMA, assertExecutionStorageSchema } from './execution-journal-tables.js';
+/** Explicit native scope consent. This store holds no token, signer, or transaction submission authority. */
+import { createHash, randomUUID } from 'node:crypto';
+import { getAddress } from 'viem';
+import { z } from 'zod';
+import { NATIVE_ACCOUNT_ADDRESS, NATIVE_ACCOUNT_AUTHORITY_SCHEMA, NATIVE_ACCOUNT_COMMITMENT, NATIVE_ACCOUNT_CONSENT_SCHEMA, NATIVE_ACCOUNT_CONSENT_TTL_MS, NATIVE_ACCOUNT_ID, NATIVE_ACCOUNT_SCOPES, NATIVE_ACCOUNT_TIME, NATIVE_ACCOUNT_USER, } from './native-yield-account-definition.js';
+import { assertExecutionJournalCompatible, readUserExecutionClaim, requireExecutionJournalReady, } from './execution-journal-schema.js';
+const DOMAIN = 'otto.native-yield.account-consent.v1';
+const CONFIRM_INPUT = z.object({
+    userId: NATIVE_ACCOUNT_USER,
+    consentId: NATIVE_ACCOUNT_ID.refine((id) => id.startsWith('nc_')),
+    consentCommitment: NATIVE_ACCOUNT_COMMITMENT,
+}).strict();
+function refuse(detail) { throw new Error(`native yield consent refused: ${detail}`); }
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (value !== null && typeof value === 'object')
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+            .map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`).join(',')}}`;
+    return JSON.stringify(value);
+}
+function immutable(value) {
+    if (value !== null && typeof value === 'object') {
+        for (const entry of Object.values(value))
+            immutable(entry);
+        Object.freeze(value);
+    }
+    return value;
+}
+function accountAddress(account) {
+    const parsed = getAddress(NATIVE_ACCOUNT_ADDRESS.parse(account));
+    if (parsed === '0x0000000000000000000000000000000000000000')
+        return refuse('the account is zero');
+    return parsed;
+}
+function time(nowMs) { return NATIVE_ACCOUNT_TIME.parse(nowMs); }
+function authorityTerms(input) {
+    const parsed = NATIVE_ACCOUNT_AUTHORITY_SCHEMA.parse(input);
+    if (parsed.scopes.some((scope, index) => scope !== NATIVE_ACCOUNT_SCOPES[index]))
+        return refuse('scopes must be unique and in the reviewed order');
+    return {
+        ...parsed,
+        account: accountAddress(parsed.account),
+        grantExpiresAt: new Date(parsed.grantExpiresAt).toISOString(),
+    };
+}
+function assertGrantValid(authority, nowMs) {
+    if (Date.parse(authority.grantExpiresAt) <= nowMs)
+        refuse('the grant has expired');
+}
+function commitment(record) {
+    return `sha256:${createHash('sha256').update(canonical({ domain: DOMAIN, ...record })).digest('hex')}`;
+}
+function consentCommitment(record) {
+    return commitment({
+        consentId: record.consentId, authority: record.authority, generation: record.generation,
+        createdAtMs: record.createdAtMs, challengeExpiresAtMs: record.challengeExpiresAtMs,
+    });
+}
+/** Nested mutations use a savepoint, so a caught refusal cannot leave part of a consent transition. */
+function transaction(db, write, body) {
+    if (typeof db.isTransaction !== 'boolean')
+        return refuse('the database transaction state is unavailable');
+    const own = !db.isTransaction;
+    const savepoint = !own && write ? `ny_consent_${randomUUID().replace(/-/g, '')}` : undefined;
+    if (own)
+        db.exec(write ? 'BEGIN IMMEDIATE' : 'BEGIN');
+    else if (savepoint)
+        db.exec(`SAVEPOINT ${savepoint}`);
+    try {
+        assertExecutionJournalCompatible(db, 3);
+        const result = body();
+        if (own)
+            db.exec('COMMIT');
+        else if (savepoint)
+            db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+        return result;
+    }
+    catch (error) {
+        try {
+            if (own)
+                db.exec('ROLLBACK');
+            else if (savepoint) {
+                db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+                db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+            }
+        }
+        catch { /* preserve the original refusal */ }
+        throw error;
+    }
+}
+function readSubject(db, userId, account) {
+    const row = db.prepare('SELECT * FROM native_yield_consent_subjects WHERE user_id=? AND account=?')
+        .get(userId, account);
+    if (!row)
+        return undefined;
+    if (row.user_id !== userId || row.account !== account || !Number.isSafeInteger(row.generation) ||
+        Number(row.generation) < 0 || !Number.isSafeInteger(row.updated_at_ms) || Number(row.updated_at_ms) < 0 ||
+        (row.active_consent_id !== null && (typeof row.active_consent_id !== 'string' || !row.active_consent_id.startsWith('nc_') ||
+            !NATIVE_ACCOUNT_ID.safeParse(row.active_consent_id).success)))
+        return refuse('the subject counter is corrupt');
+    return { userId, account, generation: row.generation, activeConsentId: row.active_consent_id,
+        updatedAtMs: row.updated_at_ms };
+}
+function parseRecord(row) {
+    if (row === undefined)
+        return undefined;
+    if (!row || typeof row !== 'object')
+        return refuse('the stored challenge is corrupt');
+    const item = row;
+    if (typeof item.authority_json !== 'string')
+        return refuse('the stored authority is corrupt');
+    let authority;
+    try {
+        authority = authorityTerms(JSON.parse(item.authority_json));
+    }
+    catch {
+        return refuse('the stored authority is corrupt');
+    }
+    if (canonical(authority) !== item.authority_json || authority.userId !== item.user_id || authority.account !== item.account)
+        return refuse('the stored authority subject or encoding changed');
+    const record = NATIVE_ACCOUNT_CONSENT_SCHEMA.parse({
+        consentId: item.consent_id, authority, consentCommitment: item.consent_commitment, state: item.state,
+        generation: item.generation, createdAtMs: item.created_at_ms, challengeExpiresAtMs: item.challenge_expires_at_ms,
+        confirmedAtMs: item.confirmed_at_ms,
+    });
+    if (!record.consentId.startsWith('nc_') || record.generation < 1 ||
+        record.challengeExpiresAtMs !== record.createdAtMs + NATIVE_ACCOUNT_CONSENT_TTL_MS ||
+        Date.parse(authority.grantExpiresAt) <= record.challengeExpiresAtMs || consentCommitment(record) !== record.consentCommitment)
+        return refuse('the stored immutable challenge terms changed');
+    if (record.state === 'confirmed' && record.confirmedAtMs === null)
+        return refuse('confirmation evidence is missing');
+    if (record.state === 'challenge' && record.confirmedAtMs !== null)
+        return refuse('an unconfirmed challenge carries confirmation evidence');
+    if (record.confirmedAtMs !== null && (record.confirmedAtMs < record.createdAtMs || record.confirmedAtMs >= record.challengeExpiresAtMs))
+        return refuse('confirmation time is outside the challenge window');
+    return immutable(record);
+}
+function readRecord(db, consentId) {
+    return parseRecord(db.prepare('SELECT * FROM native_yield_consents WHERE consent_id=?').get(consentId));
+}
+function assertSubjectCoherent(db, subject) {
+    const confirmed = db.prepare("SELECT * FROM native_yield_consents WHERE user_id=? AND account=? AND state='confirmed'")
+        .all(subject.userId, subject.account);
+    if (subject.activeConsentId === null) {
+        if (confirmed.length !== 0)
+            return refuse('a confirmed consent has no active pointer');
+        return undefined;
+    }
+    if (confirmed.length !== 1)
+        return refuse('the active consent is missing or ambiguous');
+    const record = parseRecord(confirmed[0]);
+    if (record.consentId !== subject.activeConsentId || record.generation !== subject.generation)
+        return refuse('the active consent generation changed');
+    return record;
+}
+function assertNoExecutionClaim(db, userId) {
+    if (readUserExecutionClaim(db, userId))
+        refuse('an unresolved user operation prevents a new consent');
+}
+function nextGeneration(subject) {
+    if (subject.generation >= Number.MAX_SAFE_INTEGER)
+        return refuse('the consent counter cannot advance');
+    return subject.generation + 1;
+}
+export function initializeNativeYieldConsents(db) {
+    transaction(db, true, () => {
+        assertExecutionStorageSchema(db, NATIVE_CONSENT_SCHEMA);
+        const subjects = db.prepare('SELECT user_id,account FROM native_yield_consent_subjects').all();
+        for (const item of subjects) {
+            const userId = NATIVE_ACCOUNT_USER.parse(item.user_id);
+            const account = accountAddress(NATIVE_ACCOUNT_ADDRESS.parse(item.account));
+            if (account !== item.account)
+                refuse('a stored account is not canonical');
+            assertSubjectCoherent(db, readSubject(db, userId, account));
+        }
+        const records = db.prepare('SELECT * FROM native_yield_consents').all();
+        for (const row of records) {
+            const record = parseRecord(row);
+            const subject = readSubject(db, record.authority.userId, record.authority.account);
+            if (!subject || record.generation > subject.generation + 1)
+                refuse('a challenge has no valid subject counter');
+            if (record.state === 'challenge' && record.generation !== subject.generation + 1)
+                refuse('a pending challenge is stale without an invalidation record');
+        }
+    });
+}
+/** Authenticated subject lookup for challenge review/confirmation. History is evidence, not authority. */
+export function readNativeYieldConsent(db, userId, consentId) {
+    NATIVE_ACCOUNT_USER.parse(userId);
+    NATIVE_ACCOUNT_ID.refine((id) => id.startsWith('nc_')).parse(consentId);
+    return transaction(db, false, () => parseRecord(db.prepare('SELECT * FROM native_yield_consents WHERE user_id=? AND consent_id=?').get(userId, consentId)));
+}
+export function createNativeYieldConsent(db, inputAuthority, nowMs) {
+    time(nowMs);
+    const authority = authorityTerms(inputAuthority);
+    const expires = time(nowMs + NATIVE_ACCOUNT_CONSENT_TTL_MS);
+    if (Date.parse(authority.grantExpiresAt) <= expires)
+        return refuse('the grant does not outlive the five-minute challenge');
+    return transaction(db, true, () => {
+        requireExecutionJournalReady(db);
+        assertNoExecutionClaim(db, authority.userId);
+        db.prepare(`INSERT OR IGNORE INTO native_yield_consent_subjects
+      (user_id,account,generation,active_consent_id,updated_at_ms) VALUES (?,?,0,NULL,?)`)
+            .run(authority.userId, authority.account, nowMs);
+        const subject = readSubject(db, authority.userId, authority.account);
+        assertSubjectCoherent(db, subject);
+        if (nowMs < subject.updatedAtMs)
+            return refuse('the clock predates the current consent generation');
+        const terms = {
+            consentId: `nc_${randomUUID()}`, authority, generation: nextGeneration(subject),
+            createdAtMs: nowMs, challengeExpiresAtMs: expires,
+        };
+        const record = NATIVE_ACCOUNT_CONSENT_SCHEMA.parse({ ...terms, consentCommitment: commitment(terms), state: 'challenge', confirmedAtMs: null });
+        db.prepare(`INSERT INTO native_yield_consents
+      (consent_id,user_id,account,authority_json,consent_commitment,generation,state,created_at_ms,challenge_expires_at_ms,confirmed_at_ms)
+      VALUES (?,?,?,?,?,?,'challenge',?,?,NULL)`)
+            .run(record.consentId, authority.userId, authority.account, canonical(authority), record.consentCommitment, record.generation, nowMs, expires);
+        return immutable(record);
+    });
+}
+export function confirmNativeYieldConsent(db, rawInput, inputAuthority, nowMs) {
+    time(nowMs);
+    const input = CONFIRM_INPUT.parse(rawInput);
+    const authority = authorityTerms(inputAuthority);
+    if (input.userId !== authority.userId)
+        return refuse('the confirmation belongs to another subject');
+    assertGrantValid(authority, nowMs);
+    return transaction(db, true, () => {
+        requireExecutionJournalReady(db);
+        assertNoExecutionClaim(db, authority.userId);
+        const record = readRecord(db, input.consentId);
+        if (!record || record.authority.userId !== input.userId || record.authority.account !== authority.account ||
+            record.consentCommitment !== input.consentCommitment || canonical(record.authority) !== canonical(authority))
+            return refuse('the confirmation does not match the reviewed owner and authority');
+        const subject = readSubject(db, authority.userId, authority.account);
+        if (!subject)
+            return refuse('the challenge subject is missing');
+        const active = assertSubjectCoherent(db, subject);
+        if (nowMs < subject.updatedAtMs || nowMs < record.createdAtMs)
+            return refuse('the clock predates the consent');
+        if (record.state === 'confirmed') {
+            if (active?.consentId !== record.consentId)
+                return refuse('the consent is no longer active');
+            return record;
+        }
+        if (record.state !== 'challenge' || record.generation !== nextGeneration(subject))
+            return refuse('the challenge was superseded or revoked');
+        if (nowMs >= record.challengeExpiresAtMs)
+            return refuse('the five-minute challenge has expired');
+        if (active)
+            db.prepare("UPDATE native_yield_consents SET state='superseded' WHERE consent_id=? AND state='confirmed'").run(active.consentId);
+        const confirmed = db.prepare("UPDATE native_yield_consents SET state='confirmed',confirmed_at_ms=? WHERE consent_id=? AND state='challenge'")
+            .run(nowMs, record.consentId);
+        if (Number(confirmed.changes) !== 1)
+            return refuse('the challenge changed during confirmation');
+        db.prepare("UPDATE native_yield_consents SET state='superseded' WHERE user_id=? AND account=? AND state='challenge' AND generation<=?")
+            .run(authority.userId, authority.account, record.generation);
+        const changed = db.prepare(`UPDATE native_yield_consent_subjects SET generation=?,active_consent_id=?,updated_at_ms=?
+      WHERE user_id=? AND account=? AND generation=? AND active_consent_id IS ?`)
+            .run(record.generation, record.consentId, nowMs, authority.userId, authority.account, subject.generation, subject.activeConsentId);
+        if (Number(changed.changes) !== 1)
+            return refuse('the consent generation changed during confirmation');
+        return readRecord(db, record.consentId);
+    });
+}
+export function readConfirmedNativeYieldConsent(db, userId, account, nowMs) {
+    NATIVE_ACCOUNT_USER.parse(userId);
+    time(nowMs);
+    const address = accountAddress(account);
+    return transaction(db, false, () => {
+        const subject = readSubject(db, userId, address);
+        if (!subject)
+            return undefined;
+        const record = assertSubjectCoherent(db, subject);
+        if (!record || nowMs < subject.updatedAtMs || Date.parse(record.authority.grantExpiresAt) <= nowMs)
+            return undefined;
+        return record;
+    });
+}
+/** Read-only: safe inside the operation's claim transaction and again immediately before handoff. */
+export function assertCurrentNativeYieldConsent(db, inputRecord, inputAuthority, nowMs) {
+    time(nowMs);
+    const record = NATIVE_ACCOUNT_CONSENT_SCHEMA.parse(inputRecord);
+    const authority = authorityTerms(inputAuthority);
+    assertGrantValid(authority, nowMs);
+    transaction(db, false, () => {
+        const active = readConfirmedNativeYieldConsent(db, authority.userId, authority.account, nowMs);
+        if (!active || record.state !== 'confirmed' || canonical(active) !== canonical(record) ||
+            canonical(active.authority) !== canonical(authority) || consentCommitment(record) !== record.consentCommitment)
+            refuse('the reviewed consent is no longer current for this owner and authority');
+    });
+}
+/** Stop remains available while a money operation is unresolved; it never releases that operation's claim. */
+export function revokeNativeYieldConsent(db, userId, account, nowMs) {
+    NATIVE_ACCOUNT_USER.parse(userId);
+    time(nowMs);
+    const address = accountAddress(account);
+    transaction(db, true, () => {
+        db.prepare(`INSERT OR IGNORE INTO native_yield_consent_subjects
+      (user_id,account,generation,active_consent_id,updated_at_ms) VALUES (?,?,0,NULL,?)`).run(userId, address, nowMs);
+        const subject = readSubject(db, userId, address);
+        assertSubjectCoherent(db, subject);
+        if (nowMs < subject.updatedAtMs)
+            return refuse('the clock predates the current consent generation');
+        db.prepare("UPDATE native_yield_consents SET state='revoked' WHERE user_id=? AND account=? AND state IN ('challenge','confirmed')")
+            .run(userId, address);
+        const changed = db.prepare(`UPDATE native_yield_consent_subjects SET generation=?,active_consent_id=NULL,updated_at_ms=?
+      WHERE user_id=? AND account=? AND generation=? AND active_consent_id IS ?`)
+            .run(nextGeneration(subject), nowMs, userId, address, subject.generation, subject.activeConsentId);
+        if (Number(changed.changes) !== 1)
+            return refuse('the consent generation changed during revocation');
+    });
+}
+//# sourceMappingURL=native-yield-consent-store.js.map

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

@@ -0,0 +1,288 @@
+/** Native yield contracts; separate from the existing LI.FI delegation envelope. */
+import { z } from 'zod';
+import { type Address, type Hex } from 'viem';
+import type { HybridYieldMarket, HybridYieldChainId } from './hybrid-yield-markets.js';
+export declare const NATIVE_YIELD_FEE_BPS: 10;
+export declare const NATIVE_YIELD_FEE_RECIPIENT: `0x${string}`;
+export declare const NATIVE_YIELD_FEE_VERSION = "native-yield-10bps-floor-v1";
+export declare const NATIVE_YIELD_TTL_SECONDS = 180;
+export declare const NATIVE_YIELD_STATE_MAX_AGE_MS = 60000;
+export declare const NATIVE_YIELD_ROUTER_ABI: readonly [{
+    readonly name: "execute";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "marketId";
+    }, {
+        readonly type: "bool";
+        readonly name: "isDeposit";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "minOutput";
+    }, {
+        readonly type: "uint256";
+        readonly name: "nonce";
+    }, {
+        readonly type: "uint256";
+        readonly name: "deadline";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "outputAmount";
+    }];
+}, {
+    readonly name: "nonces";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "marketConfig";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "marketId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+        readonly name: "protocol";
+    }, {
+        readonly type: "address";
+        readonly name: "asset";
+    }, {
+        readonly type: "address";
+        readonly name: "position";
+    }, {
+        readonly type: "address";
+        readonly name: "target";
+    }, {
+        readonly type: "bool";
+        readonly name: "depositEnabled";
+    }];
+}, {
+    readonly name: "YieldExecuted";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+        readonly indexed: true;
+    }, {
+        readonly type: "bytes32";
+        readonly name: "marketId";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "nonce";
+        readonly indexed: true;
+    }, {
+        readonly type: "bool";
+        readonly name: "isDeposit";
+    }, {
+        readonly type: "uint256";
+        readonly name: "inputAmount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "outputAmount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "feeAmount";
+    }];
+}];
+export declare const NATIVE_YIELD_ERC20_ABI: readonly [{
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "decimals";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+    }];
+}, {
+    readonly name: "totalSupply";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "Transfer";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "from";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "to";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "value";
+    }];
+}];
+export declare const PREPARE_NATIVE_YIELD_INPUT_SCHEMA: 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>;
+export type PrepareNativeYieldInput = z.infer<typeof PREPARE_NATIVE_YIELD_INPUT_SCHEMA>;
+export declare const NATIVE_YIELD_DEPLOYMENT_SCHEMA: 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>;
+export type NativeYieldDeployment = z.infer<typeof NATIVE_YIELD_DEPLOYMENT_SCHEMA>;
+/**
+ * Deliberately empty. No address/environment variable can activate a new spend
+ * target. Fill only in a separately approved exact-deployment review.
+ */
+export declare const NATIVE_YIELD_DEPLOYMENTS: readonly NativeYieldDeployment[];
+export interface NativeYieldState {
+    readonly chainId: HybridYieldChainId;
+    readonly marketId: string;
+    readonly owner: Address;
+    readonly blockNumber: bigint;
+    readonly blockHash: Hex;
+    readonly blockTimestampMs: number;
+    readonly observedAtMs: number;
+    readonly routerNonce: bigint;
+    readonly inputBalance: bigint;
+    readonly inputAllowance: bigint;
+    readonly positionBalance: bigint;
+    readonly assetBalance: bigint;
+    readonly nativeBalance: bigint;
+    readonly maxInput: bigint;
+    /** Deposit: net aToken/shares after fee. Withdraw: gross underlying before fee. */
+    readonly protocolOutput: bigint;
+}
+export interface NativeYieldReader {
+    read(market: HybridYieldMarket, owner: Address, action: 'deposit' | 'withdraw', amount: bigint, deployment: NativeYieldDeployment): Promise<NativeYieldState>;
+}
+export declare const NATIVE_YIELD_PLAN_SCHEMA: 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>;
+export type NativeYieldPlan = z.infer<typeof NATIVE_YIELD_PLAN_SCHEMA>;
+export declare function nativeYieldFee(gross: bigint): bigint;
+export declare class NativeYieldRefusal extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function refuseNative(code: string, message: string): never;