otto-intel-mcp 0.1.2 → 0.1.4

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

@@ -0,0 +1,525 @@
+/** Native account policy compilation, exact readback fences and approved amount/oracle limits. */
+import { createHash } from 'node:crypto';
+import { getAddress, keccak256, stringToHex, } from 'viem';
+import { MODEL_B_CAP_RULESET_VERSION, MODEL_B_PER_SWAP_CAP_MIN_USD, MODEL_B_PER_SWAP_CAP_USD, MODEL_B_POLICY_DIGEST_V2, MODEL_B_POLICY_NAME_V2, modelBProjectPolicyRules, } from './execution-delegation-policy.js';
+import { policyRulesDigest } from './execution-policy-compatibility.js';
+import { NATIVE_ACCOUNT_ACTIVATION_SCHEMA, NATIVE_ACCOUNT_AUTHORITY_SCHEMA, NATIVE_ACCOUNT_POLICY_NAME, NATIVE_ACCOUNT_SCOPES, NATIVE_YIELD_ACCOUNT_ACTIVATIONS, } from './native-yield-account-definition.js';
+import { NATIVE_YIELD_STATE_MAX_AGE_MS, refuseNative, } from './native-yield-definition.js';
+import { freezeHybridValue, getHybridYieldMarket, hybridYieldCommitment, } from './hybrid-yield-markets.js';
+const UINT256_MAX = (1n << 256n) - 1n;
+const ZERO_ADDRESS = /^0x0{40}$/i;
+const ZERO_HASH = /^0x0{64}$/i;
+const BLOCK_FUTURE_SKEW_MS = 5_000;
+/** The only custom call shape admitted by the native project-policy leaves. */
+export const NATIVE_ACCOUNT_ROUTER_EXECUTE_ABI = [
+    {
+        type: 'function',
+        name: 'execute',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'marketId', type: 'bytes32' },
+            { name: 'isDeposit', type: 'bool' },
+            { name: 'amount', type: 'uint256' },
+            { name: 'minOutput', type: 'uint256' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' },
+        ],
+        outputs: [{ name: 'outputAmount', type: 'uint256' }],
+    },
+];
+function canonical(value) {
+    if (value === null || ['string', 'boolean'].includes(typeof value))
+        return JSON.stringify(value);
+    if (typeof value === 'number' && Number.isFinite(value))
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (typeof value === 'object') {
+        return `{${Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`)
+            .join(',')}}`;
+    }
+    return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Activation contains a non-canonical value');
+}
+function activationSnapshot(raw) {
+    try {
+        return freezeHybridValue(NATIVE_ACCOUNT_ACTIVATION_SCHEMA.parse(raw));
+    }
+    catch {
+        return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Native account activation does not match its strict schema');
+    }
+}
+function exactAddress(raw, label) {
+    try {
+        const value = getAddress(raw);
+        if (ZERO_ADDRESS.test(value))
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', `${label} cannot be zero`);
+        return value;
+    }
+    catch {
+        return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', `${label} is not an exact EVM address`);
+    }
+}
+function configuration(raw) {
+    const activation = activationSnapshot(raw);
+    if (activation.policyId.trim() !== activation.policyId || activation.reviewId.trim() !== activation.reviewId) {
+        return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Activation identifiers must be exact non-whitespace values');
+    }
+    const deployments = new Map();
+    for (const deployment of activation.deployments) {
+        if (deployments.has(deployment.chainId)) {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Activation carries more than one router for a chain');
+        }
+        exactAddress(deployment.address, 'Router deployment');
+        if (ZERO_HASH.test(deployment.runtimeCodeHash)) {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Router runtime-code hash cannot be zero');
+        }
+        deployments.set(deployment.chainId, deployment);
+    }
+    const gasLimits = new Map();
+    for (const limits of activation.gasLimits) {
+        if (gasLimits.has(limits.chainId)) {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Activation carries duplicate gas limits for a chain');
+        }
+        if (BigInt(limits.maxPriorityFeePerGasWei) > BigInt(limits.maxFeePerGasWei) ||
+            BigInt(limits.maxEstimatedTotalCostWei) > BigInt(limits.maxOperationEstimatedCostWei)) {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Approved gas limits are internally inconsistent');
+        }
+        gasLimits.set(limits.chainId, limits);
+    }
+    const keys = new Set();
+    const usedChains = new Set();
+    const markets = [];
+    for (const rule of activation.marketRules) {
+        const key = `${rule.marketId}\u0000${rule.action}`;
+        if (keys.has(key)) {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Activation carries a duplicate market/action limit');
+        }
+        keys.add(key);
+        const market = getHybridYieldMarket(rule.marketId);
+        if (!market || hybridYieldCommitment(market) !== rule.registryCommitment) {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', `Activation market ${rule.marketId} is absent or has drifted`);
+        }
+        if (!deployments.has(market.chainId) || !gasLimits.has(market.chainId)) {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', `Activation lacks router or gas limits for ${rule.marketId}`);
+        }
+        // Recovery mode retains reviewed policy terms so exact old approvals can still be cleared.
+        // It is an application stop, not provider-level removal of native capability.
+        if (rule.action === 'deposit' &&
+            market.capabilities.native.deposit !== 'gated') {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', `Deposit is not approved for ${rule.marketId}`);
+        }
+        if (rule.action === 'withdraw' && market.capabilities.native.withdraw !== 'gated') {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', `Withdrawal is not approved for ${rule.marketId}`);
+        }
+        usedChains.add(market.chainId);
+        markets.push(Object.freeze({ rule, market }));
+    }
+    if (deployments.size !== usedChains.size || gasLimits.size !== usedChains.size ||
+        [...deployments.keys()].some((chainId) => !usedChains.has(chainId)) ||
+        [...gasLimits.keys()].some((chainId) => !usedChains.has(chainId))) {
+        return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Router, market and gas chain coverage must match exactly');
+    }
+    const requiredPrices = new Map();
+    for (const binding of markets) {
+        if (binding.rule.action === 'deposit' && binding.market.asset.symbol === 'WETH') {
+            requiredPrices.set(`${binding.market.chainId}:${binding.market.asset.address.toLowerCase()}`, binding.market);
+        }
+    }
+    const seenPrices = new Set();
+    for (const price of activation.priceRules) {
+        const asset = exactAddress(price.asset, 'Price-rule asset');
+        exactAddress(price.feed, 'Price feed');
+        const key = `${price.chainId}:${asset.toLowerCase()}`;
+        const market = requiredPrices.get(key);
+        if (!market || seenPrices.has(key) || BigInt(price.minimumAnswer) > BigInt(price.maximumAnswer)) {
+            return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Price rules must exactly cover approved WETH deposits with a valid corridor');
+        }
+        seenPrices.add(key);
+    }
+    if (seenPrices.size !== requiredPrices.size) {
+        return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Every approved WETH deposit needs one exact price rule');
+    }
+    return Object.freeze({
+        activation,
+        deployments,
+        gasLimits,
+        markets: Object.freeze(markets),
+    });
+}
+function orderedBindings(config, chainId) {
+    return config.markets
+        .filter((binding) => binding.market.chainId === chainId)
+        .slice()
+        .sort((a, b) => a.market.id.localeCompare(b.market.id) || a.rule.action.localeCompare(b.rule.action));
+}
+function network(chainId) {
+    return chainId === 8453 ? 'base' : 'arbitrum';
+}
+/** Compile only the native leaves. Every leaf binds the CDP request network explicitly. */
+export function compileNativeYieldAccountPolicyRules(raw) {
+    const config = configuration(raw);
+    const rules = [];
+    const chains = [...config.deployments.keys()].sort((a, b) => a - b);
+    for (const chainId of chains) {
+        const bindings = orderedBindings(config, chainId);
+        const deployment = config.deployments.get(chainId);
+        const tokens = new Map();
+        let chainMaximum = 0n;
+        for (const binding of bindings) {
+            const token = exactAddress(binding.rule.action === 'deposit'
+                ? binding.market.asset.address
+                : binding.market.position.tokenAddress, 'Native approval token');
+            tokens.set(token.toLowerCase(), token);
+            const maximum = BigInt(binding.rule.maximumInputAtomic);
+            if (maximum > chainMaximum)
+                chainMaximum = maximum;
+        }
+        const tokenAddresses = [...tokens.values()].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+        const router = exactAddress(deployment.address, 'Native router');
+        const chainNetwork = network(chainId);
+        rules.push({
+            action: 'accept',
+            operation: 'sendEndUserEvmTransaction',
+            criteria: [
+                { type: 'evmNetwork', networks: [chainNetwork], operator: 'in' },
+                { type: 'evmAddress', addresses: tokenAddresses, operator: 'in' },
+                { type: 'ethValue', ethValue: '0', operator: '<=' },
+                {
+                    type: 'evmData',
+                    abi: 'erc20',
+                    conditions: [{
+                            function: 'approve',
+                            params: [
+                                { name: 'spender', operator: 'in', values: [router] },
+                                { name: 'value', operator: '<=', value: chainMaximum.toString() },
+                            ],
+                        }],
+                },
+            ],
+        });
+        rules.push({
+            action: 'accept',
+            operation: 'sendEndUserEvmTransaction',
+            criteria: [
+                { type: 'evmNetwork', networks: [chainNetwork], operator: 'in' },
+                { type: 'evmAddress', addresses: [router], operator: 'in' },
+                { type: 'ethValue', ethValue: '0', operator: '<=' },
+                {
+                    type: 'evmData',
+                    abi: NATIVE_ACCOUNT_ROUTER_EXECUTE_ABI,
+                    conditions: bindings.map((binding) => ({
+                        function: 'execute',
+                        params: [
+                            {
+                                name: 'marketId',
+                                operator: 'in',
+                                values: [keccak256(stringToHex(binding.market.id))],
+                            },
+                            {
+                                name: 'isDeposit',
+                                operator: 'in',
+                                values: [binding.rule.action === 'deposit' ? 'true' : 'false'],
+                            },
+                            {
+                                name: 'amount',
+                                operator: '<=',
+                                value: binding.rule.maximumInputAtomic,
+                            },
+                        ],
+                    })),
+                },
+            ],
+        });
+    }
+    return freezeHybridValue(rules);
+}
+/**
+ * Compile exact legacy-v2 leaves followed by native leaves. Coinbase project policies apply
+ * retroactively: parsing or digesting this body does not authorize attaching it. Before any update,
+ * every live grant needs a separate consent audit for this exact policy id/digest and activation.
+ */
+export function compileNativeYieldAccountCompositePolicy(activation) {
+    const legacyRules = modelBProjectPolicyRules();
+    const nativeRules = compileNativeYieldAccountPolicyRules(activation);
+    const rules = freezeHybridValue([...legacyRules, ...nativeRules]);
+    if (rules.length > 10) {
+        return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Composite policy exceeds the CDP ten-rule ceiling');
+    }
+    const body = freezeHybridValue({
+        scope: 'project',
+        description: NATIVE_ACCOUNT_POLICY_NAME,
+        rules,
+    });
+    return Object.freeze({
+        body,
+        legacyRules,
+        nativeRules,
+        policyDigest: policyRulesDigest(rules),
+        legacyRulesDigest: policyRulesDigest(legacyRules),
+        nativeRulesDigest: policyRulesDigest(nativeRules),
+    });
+}
+/** Validate all trusted pins and the full/leaf policy digests. */
+export function validateNativeYieldAccountActivation(raw) {
+    const activation = configuration(raw).activation;
+    const compiled = compileNativeYieldAccountCompositePolicy(activation);
+    if (compiled.legacyRulesDigest !== MODEL_B_POLICY_DIGEST_V2 ||
+        activation.legacyRulesDigest !== compiled.legacyRulesDigest ||
+        activation.nativeRulesDigest !== compiled.nativeRulesDigest ||
+        activation.policyDigest !== compiled.policyDigest) {
+        return refuseNative('NATIVE_ACCOUNT_ACTIVATION_INVALID', 'Activation policy or leaf digest does not match the deterministic composite');
+    }
+    return compiled;
+}
+/** Domain-separated commitment used by persisted native-scope consent. */
+export function nativeYieldAccountActivationCommitment(raw) {
+    const activation = configuration(raw).activation;
+    validateNativeYieldAccountActivation(activation);
+    return `sha256:${createHash('sha256')
+        .update(`otto:native-yield-account-activation:v1:${canonical(activation)}`)
+        .digest('hex')}`;
+}
+/** Resolve only an exact reviewed constant/test manifest; the production default is empty. */
+export function resolveNativeYieldAccountActivation(chainId, activations = NATIVE_YIELD_ACCOUNT_ACTIVATIONS) {
+    if (chainId !== 8453 && chainId !== 42161) {
+        return refuseNative('NATIVE_ACCOUNT_ACTIVATION_UNAVAILABLE', 'Native account chain is unsupported');
+    }
+    const parsed = activations.map((activation) => {
+        const snapshot = configuration(activation).activation;
+        validateNativeYieldAccountActivation(snapshot);
+        return snapshot;
+    });
+    const matches = parsed.filter((activation) => activation.deployments.some((deployment) => deployment.chainId === chainId));
+    if (matches.length !== 1) {
+        return refuseNative('NATIVE_ACCOUNT_ACTIVATION_UNAVAILABLE', matches.length === 0
+            ? 'No reviewed native account activation exists for this chain'
+            : 'More than one native account activation claims this chain');
+    }
+    return matches[0];
+}
+function exactProjectPolicy(policies) {
+    const project = policies.filter((policy) => policy.scope === 'project');
+    if (project.length !== 1) {
+        return refuseNative('NATIVE_ACCOUNT_POLICY_MISMATCH', project.length === 0
+            ? 'No project policy is installed'
+            : 'Project policy readback is ambiguous');
+    }
+    return project[0];
+}
+function targetFence(activation) {
+    return Object.freeze({
+        policyId: activation.policyId,
+        policyName: activation.policyName,
+        policyDigest: activation.policyDigest,
+        legacyRulesDigest: activation.legacyRulesDigest,
+        nativeRulesDigest: activation.nativeRulesDigest,
+    });
+}
+function assertExactComposite(policy, activation, compiled) {
+    if (policy.id !== activation.policyId || policy.description !== activation.policyName || !Array.isArray(policy.rules) ||
+        policy.rules.length !== compiled.body.rules.length) {
+        return refuseNative('NATIVE_ACCOUNT_POLICY_MISMATCH', 'Installed project policy has the wrong id, name or rule count');
+    }
+    const full = policyRulesDigest(policy.rules);
+    const legacy = policyRulesDigest(policy.rules.slice(0, compiled.legacyRules.length));
+    const native = policyRulesDigest(policy.rules.slice(compiled.legacyRules.length));
+    if (full !== activation.policyDigest || legacy !== activation.legacyRulesDigest || native !== activation.nativeRulesDigest ||
+        full !== compiled.policyDigest || legacy !== compiled.legacyRulesDigest || native !== compiled.nativeRulesDigest) {
+        return refuseNative('NATIVE_ACCOUNT_POLICY_MISMATCH', 'Installed project policy does not match the exact full and leaf digests');
+    }
+    return full;
+}
+/**
+ * Consent may be challenged immediately before an in-place v2→v3 attach at the same policy id. The
+ * returned common fields always name the prospective exact v3; observed fields identify what was read.
+ */
+export function assertNativeConsentPolicyContext(policies, raw) {
+    const activation = configuration(raw).activation;
+    const compiled = validateNativeYieldAccountActivation(activation);
+    const policy = exactProjectPolicy(policies);
+    if (policy.id !== activation.policyId) {
+        return refuseNative('NATIVE_ACCOUNT_POLICY_MISMATCH', 'Consent policy id differs from the planned in-place composite policy');
+    }
+    const observedPolicyDigest = policyRulesDigest(policy.rules);
+    if (policy.description === MODEL_B_POLICY_NAME_V2 && observedPolicyDigest === MODEL_B_POLICY_DIGEST_V2) {
+        return Object.freeze({
+            ...targetFence(activation),
+            phase: 'legacy-v2',
+            observedPolicyName: MODEL_B_POLICY_NAME_V2,
+            observedPolicyDigest,
+        });
+    }
+    const full = assertExactComposite(policy, activation, compiled);
+    return Object.freeze({
+        ...targetFence(activation),
+        phase: 'native-v3',
+        observedPolicyName: activation.policyName,
+        observedPolicyDigest: full,
+    });
+}
+/** A sender proceeds only while the exact v3 id, name, full digest and both leaf digests read back. */
+export function assertNativeAccountSendFence(policies, raw) {
+    const activation = configuration(raw).activation;
+    const compiled = validateNativeYieldAccountActivation(activation);
+    const policy = exactProjectPolicy(policies);
+    assertExactComposite(policy, activation, compiled);
+    return targetFence(activation);
+}
+export function deriveExactApprovedNativeMarketLimits(raw, input) {
+    const config = configuration(raw);
+    validateNativeYieldAccountActivation(config.activation);
+    const binding = config.markets.find(({ market, rule }) => market.chainId === input.chainId && market.id === input.marketId &&
+        rule.action === input.action && rule.registryCommitment === input.registryCommitment);
+    if (!binding || hybridYieldCommitment(binding.market) !== input.registryCommitment) {
+        return refuseNative('NATIVE_ACCOUNT_OUTSIDE_FENCE', 'Market, action, chain or registry commitment is outside the approved activation');
+    }
+    if (input.action === 'deposit' && config.activation.mode !== 'enabled') {
+        return refuseNative('NATIVE_ACCOUNT_OUTSIDE_FENCE', 'Recovery-only activation cannot create a new position');
+    }
+    const deployment = config.deployments.get(input.chainId);
+    const gasLimits = config.gasLimits.get(input.chainId);
+    const inputToken = exactAddress(input.action === 'deposit' ? binding.market.asset.address : binding.market.position.tokenAddress, 'Native input token');
+    return Object.freeze({
+        activation: config.activation,
+        deployment,
+        market: binding.market,
+        marketRule: binding.rule,
+        gasLimits,
+        network: network(input.chainId),
+        inputToken,
+        maximumInputAtomic: BigInt(binding.rule.maximumInputAtomic),
+    });
+}
+function boundedAmount(amount) {
+    if (typeof amount !== 'bigint' || amount <= 0n || amount > UINT256_MAX) {
+        return refuseNative('NATIVE_ACCOUNT_OUTSIDE_FENCE', 'Input amount must be an exact positive uint256');
+    }
+    return amount;
+}
+/** Applies to deposits and withdrawals; withdrawals need no price conversion. */
+export function assertNativeInputWithinApprovedAtomicCeiling(amountAtomic, limits) {
+    const amount = boundedAmount(amountAtomic);
+    const expected = deriveExactApprovedNativeMarketLimits(limits.activation, {
+        chainId: limits.market.chainId,
+        marketId: limits.market.id,
+        registryCommitment: limits.marketRule.registryCommitment,
+        action: limits.marketRule.action,
+    });
+    if (expected.maximumInputAtomic !== limits.maximumInputAtomic ||
+        expected.inputToken !== limits.inputToken ||
+        expected.deployment.address.toLowerCase() !== limits.deployment.address.toLowerCase()) {
+        return refuseNative('NATIVE_ACCOUNT_OUTSIDE_FENCE', 'Resolved native limits were altered after trusted activation lookup');
+    }
+    if (amount > expected.maximumInputAtomic) {
+        return refuseNative('NATIVE_ACCOUNT_OUTSIDE_FENCE', 'Input amount exceeds the exact approved market/action ceiling');
+    }
+    return Object.freeze({ maximumInputAtomic: expected.maximumInputAtomic });
+}
+function exactAuthority(raw, activation, nowMs) {
+    let authority;
+    try {
+        authority = NATIVE_ACCOUNT_AUTHORITY_SCHEMA.parse(raw);
+    }
+    catch {
+        return refuseNative('NATIVE_ACCOUNT_OUTSIDE_FENCE', 'Native account authority is not a strict consent record');
+    }
+    if (!Number.isSafeInteger(nowMs) || nowMs <= 0 || Date.parse(authority.grantExpiresAt) <= nowMs ||
+        authority.capRulesetVersion !== MODEL_B_CAP_RULESET_VERSION ||
+        authority.policyId !== activation.policyId || authority.policyName !== activation.policyName ||
+        authority.policyDigest !== activation.policyDigest || authority.legacyRulesDigest !== activation.legacyRulesDigest ||
+        authority.nativeRulesDigest !== activation.nativeRulesDigest ||
+        authority.activationCommitment !== nativeYieldAccountActivationCommitment(activation) ||
+        authority.scopes.length !== NATIVE_ACCOUNT_SCOPES.length ||
+        NATIVE_ACCOUNT_SCOPES.some((scope, index) => authority.scopes[index] !== scope) ||
+        !Number.isInteger(authority.perSwapCapUsd) ||
+        authority.perSwapCapUsd < MODEL_B_PER_SWAP_CAP_MIN_USD ||
+        authority.perSwapCapUsd > MODEL_B_PER_SWAP_CAP_USD) {
+        return refuseNative('NATIVE_ACCOUNT_OUTSIDE_FENCE', 'Native account authority is expired or differs from the current activation and cap ruleset');
+    }
+    return freezeHybridValue(authority);
+}
+function ceilDiv(numerator, denominator) {
+    if (denominator <= 0n)
+        return refuseNative('NATIVE_ACCOUNT_ORACLE_INVALID', 'Price denominator must be positive');
+    return (numerator + denominator - 1n) / denominator;
+}
+function exactPriceObservation(raw, limits, nowMs) {
+    if (!raw)
+        return refuseNative('NATIVE_ACCOUNT_ORACLE_UNAVAILABLE', 'An approved current Chainlink WETH observation is required');
+    const rule = limits.activation.priceRules.find((candidate) => candidate.chainId === limits.market.chainId &&
+        candidate.asset.toLowerCase() === limits.market.asset.address.toLowerCase());
+    if (!rule)
+        return refuseNative('NATIVE_ACCOUNT_ORACLE_UNAVAILABLE', 'No approved WETH price rule exists for this market');
+    let asset;
+    let feed;
+    try {
+        asset = getAddress(raw.asset);
+        feed = getAddress(raw.feed);
+    }
+    catch {
+        return refuseNative('NATIVE_ACCOUNT_ORACLE_INVALID', 'Price observation carries an invalid address');
+    }
+    const timesValid = Number.isSafeInteger(raw.blockTimestampMs) && raw.blockTimestampMs > 0 &&
+        Number.isSafeInteger(raw.observedAtMs) && raw.observedAtMs > 0 &&
+        raw.observedAtMs <= nowMs && nowMs - raw.observedAtMs < NATIVE_YIELD_STATE_MAX_AGE_MS &&
+        raw.blockTimestampMs <= nowMs + BLOCK_FUTURE_SKEW_MS &&
+        nowMs - raw.blockTimestampMs < NATIVE_YIELD_STATE_MAX_AGE_MS &&
+        raw.blockTimestampMs <= raw.observedAtMs + BLOCK_FUTURE_SKEW_MS;
+    const bigintsValid = [raw.roundId, raw.answer, raw.startedAt, raw.updatedAt,
+        raw.answeredInRound, raw.blockNumber].every((value) => typeof value === 'bigint' && value >= 0n);
+    if (raw.chainId !== limits.market.chainId || asset !== getAddress(rule.asset) || feed !== getAddress(rule.feed) ||
+        raw.feedDecimals !== rule.feedDecimals || !timesValid || !bigintsValid ||
+        raw.roundId === 0n || raw.answer === 0n || raw.startedAt === 0n || raw.updatedAt === 0n ||
+        raw.blockNumber === 0n || raw.answeredInRound < raw.roundId || raw.startedAt > raw.updatedAt ||
+        !/^0x[0-9a-fA-F]{64}$/.test(raw.blockHash) || ZERO_HASH.test(raw.blockHash)) {
+        return refuseNative('NATIVE_ACCOUNT_ORACLE_INVALID', 'Price observation identity, round or block anchor is invalid');
+    }
+    const blockSeconds = BigInt(Math.floor(raw.blockTimestampMs / 1000));
+    if (raw.updatedAt > blockSeconds || blockSeconds - raw.updatedAt > BigInt(rule.maxAgeSeconds) ||
+        raw.answer < BigInt(rule.minimumAnswer) || raw.answer > BigInt(rule.maximumAnswer)) {
+        return refuseNative('NATIVE_ACCOUNT_ORACLE_INVALID', 'Price observation is stale or outside the approved corridor');
+    }
+    return Object.freeze({ observation: raw, rule });
+}
+/** Deposits apply the owner USD cap; withdrawals apply only their exact activation atomic ceiling. */
+export function assertNativeDepositWithinOwnerUsdCap(args) {
+    const amount = boundedAmount(args.amountAtomic);
+    assertNativeInputWithinApprovedAtomicCeiling(amount, args.limits);
+    const authority = exactAuthority(args.authority, args.limits.activation, args.nowMs);
+    const capUsdCents = BigInt(authority.perSwapCapUsd) * 100n;
+    if (args.limits.marketRule.action === 'withdraw') {
+        return Object.freeze({ capUsd: authority.perSwapCapUsd, capUsdCents });
+    }
+    if (args.limits.market.asset.symbol === 'USDC' && args.limits.market.asset.decimals === 6) {
+        const capAtomic = BigInt(authority.perSwapCapUsd) * 1000000n;
+        if (amount > capAtomic) {
+            return refuseNative('NATIVE_ACCOUNT_ABOVE_USER_CAP', 'USDC deposit exceeds the owner-confirmed USD cap');
+        }
+        return Object.freeze({
+            capUsd: authority.perSwapCapUsd,
+            capUsdCents,
+            valuedUsdCents: ceilDiv(amount * 100n, 1000000n),
+        });
+    }
+    if (args.limits.market.asset.symbol !== 'WETH' || args.limits.market.asset.decimals !== 18) {
+        return refuseNative('NATIVE_ACCOUNT_ORACLE_UNAVAILABLE', 'Only exact six-decimal USDC and approved WETH deposits have USD cap rules');
+    }
+    const { observation, rule } = exactPriceObservation(args.priceObservation, args.limits, args.nowMs);
+    const adjustedPrice = ceilDiv(observation.answer * BigInt(10_000 + rule.upwardMarginBps), 10000n);
+    const denominator = 10n ** 18n * 10n ** BigInt(rule.feedDecimals);
+    const valuedUsdCents = ceilDiv(amount * adjustedPrice * 100n, denominator);
+    if (valuedUsdCents > capUsdCents) {
+        return refuseNative('NATIVE_ACCOUNT_ABOVE_USER_CAP', 'WETH deposit exceeds the owner-confirmed USD cap after conservative valuation');
+    }
+    return Object.freeze({
+        capUsd: authority.perSwapCapUsd,
+        capUsdCents,
+        valuedUsdCents,
+        adjustedPrice,
+        priceRuleReviewId: rule.reviewId,
+    });
+}
+//# sourceMappingURL=native-yield-account-policy.js.map

package/dist/native-yield-account-rpc.d.ts

@@ -0,0 +1,8 @@
+/** Read-only transaction identity and canonical receipt proof; no signing or retry. */
+import { type Hex, type PublicClient } from 'viem';
+import { type NativeYieldAccountReceipt, type NativeYieldAccountSendRequest } from './native-yield-account-definition.js';
+/**
+ * Transport proof only. Native protocol events, output, fees and allowance recovery
+ * remain the responsibility of native-yield-settlement.ts. A mined proof is not finality.
+ */
+export declare function proveNativeYieldAccountTransaction(pub: PublicClient, rawRequest: NativeYieldAccountSendRequest, rawHash: Hex, finality: 'mined' | 'finalized'): Promise<NativeYieldAccountReceipt>;

package/dist/native-yield-account-rpc.js

@@ -0,0 +1,128 @@
+/** Read-only transaction identity and canonical receipt proof; no signing or retry. */
+import { isAddress, parseTransaction, serializeTransaction, } from 'viem';
+import { NATIVE_ACCOUNT_HASH, NATIVE_ACCOUNT_RECEIPT_SCHEMA, NATIVE_ACCOUNT_SEND_REQUEST_SCHEMA, } from './native-yield-account-definition.js';
+import { NativeYieldRefusal, refuseNative } from './native-yield-definition.js';
+const UINT256_MAX = (1n << 256n) - 1n;
+function same(a, b) { return typeof a === 'string' && a.toLowerCase() === b.toLowerCase(); }
+function uint(value) {
+    return typeof value === 'bigint' && value >= 0n && value <= UINT256_MAX;
+}
+function index(value) { return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0; }
+function sealed(block, number, hash) {
+    if (!block || block.number !== number || !same(block.hash, hash))
+        refuseNative('NATIVE_ACCOUNT_TRANSACTION_MISMATCH', 'Receipt block is not the expected canonical block');
+}
+function checkChain(pub, actual, expected) {
+    if (actual !== expected || (pub.chain && pub.chain.id !== expected))
+        refuseNative('NATIVE_CHAIN_MISMATCH', 'Receipt RPC or client configuration differs from the durable request network');
+}
+function expectedTransaction(request) {
+    try {
+        const decoded = parseTransaction(request.transaction);
+        const chainId = request.network === 'base' ? 8453 : 42161;
+        if (decoded.type !== 'eip1559' || decoded.chainId !== chainId || !decoded.to ||
+            !isAddress(decoded.to, { strict: false }) || !index(decoded.nonce) ||
+            !uint(decoded.gas) || decoded.gas === 0n || decoded.gas >= (1n << 64n) ||
+            !uint(decoded.maxFeePerGas) || decoded.maxFeePerGas === 0n ||
+            !uint(decoded.maxPriorityFeePerGas ?? 0n) || (decoded.maxPriorityFeePerGas ?? 0n) > decoded.maxFeePerGas ||
+            !uint(decoded.value ?? 0n))
+            refuseNative('NATIVE_ACCOUNT_REQUEST_INVALID', 'Durable request is not a complete supported EIP-1559 transaction');
+        const expected = {
+            type: 'eip1559', chainId, to: decoded.to, data: decoded.data ?? '0x', value: decoded.value ?? 0n,
+            nonce: decoded.nonce, gas: decoded.gas, maxFeePerGas: decoded.maxFeePerGas,
+            maxPriorityFeePerGas: decoded.maxPriorityFeePerGas ?? 0n, accessList: decoded.accessList ?? [],
+        };
+        // Rebuilding only unsigned fields rejects signatures and noncanonical RLP in durable input.
+        if (!same(serializeTransaction(expected), request.transaction))
+            refuseNative('NATIVE_ACCOUNT_REQUEST_INVALID', 'Durable transaction must contain exact canonical unsigned bytes');
+        return expected;
+    }
+    catch (error) {
+        if (error instanceof NativeYieldRefusal)
+            throw error;
+        return refuseNative('NATIVE_ACCOUNT_REQUEST_INVALID', 'Durable transaction could not be decoded');
+    }
+}
+function exactTransaction(transaction, expected, request, hash) {
+    if (transaction.type !== 'eip1559' || !same(transaction.hash, hash) ||
+        !same(transaction.from, request.address) || !same(transaction.to, expected.to) ||
+        !same(transaction.input, expected.data) || transaction.value !== expected.value ||
+        transaction.nonce !== expected.nonce || transaction.gas !== expected.gas ||
+        transaction.maxFeePerGas !== expected.maxFeePerGas ||
+        transaction.maxPriorityFeePerGas !== expected.maxPriorityFeePerGas ||
+        transaction.chainId !== expected.chainId || !Array.isArray(transaction.accessList))
+        return false;
+    try {
+        // The access list also affects signed identity; compare the entire reconstructed unsigned RLP.
+        return same(serializeTransaction({ ...expected, accessList: transaction.accessList }), request.transaction);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Transport proof only. Native protocol events, output, fees and allowance recovery
+ * remain the responsibility of native-yield-settlement.ts. A mined proof is not finality.
+ */
+export async function proveNativeYieldAccountTransaction(pub, rawRequest, rawHash, finality) {
+    const parsed = NATIVE_ACCOUNT_SEND_REQUEST_SCHEMA.safeParse(rawRequest);
+    if (!parsed.success || !NATIVE_ACCOUNT_HASH.safeParse(rawHash).success ||
+        (finality !== 'mined' && finality !== 'finalized'))
+        refuseNative('NATIVE_ACCOUNT_REQUEST_INVALID', 'Invalid durable request, transaction hash or finality requirement');
+    const request = parsed.data, hash = rawHash.toLowerCase();
+    const expected = expectedTransaction(request);
+    try {
+        checkChain(pub, await pub.getChainId(), expected.chainId);
+        const [transaction, receipt] = await Promise.all([
+            pub.getTransaction({ hash }), pub.getTransactionReceipt({ hash }),
+        ]);
+        if (!transaction || !receipt || transaction.blockHash === null || transaction.blockNumber === null)
+            refuseNative('NATIVE_ACCOUNT_TRANSACTION_UNKNOWN', 'A mined transaction and receipt are not both available');
+        if (!exactTransaction(transaction, expected, request, hash))
+            refuseNative('NATIVE_ACCOUNT_TRANSACTION_MISMATCH', 'RPC transaction differs from the exact durable request');
+        if (!uint(receipt.blockNumber) || !uint(receipt.gasUsed) || !uint(receipt.effectiveGasPrice))
+            refuseNative('NATIVE_ACCOUNT_TRANSACTION_UNKNOWN', 'Receipt has missing or invalid numeric fields');
+        const observed = NATIVE_ACCOUNT_RECEIPT_SCHEMA.safeParse({
+            transactionHash: receipt.transactionHash, blockHash: receipt.blockHash, blockNumber: receipt.blockNumber.toString(),
+            status: receipt.status, gasUsed: receipt.gasUsed.toString(), effectiveGasPrice: receipt.effectiveGasPrice.toString(),
+        });
+        if (!observed.success)
+            refuseNative('NATIVE_ACCOUNT_TRANSACTION_UNKNOWN', 'Receipt is incomplete or has unknown execution status');
+        if (receipt.type !== 'eip1559' || !same(receipt.transactionHash, hash) ||
+            !same(receipt.from, request.address) || !same(receipt.to, expected.to) ||
+            !same(transaction.blockHash, receipt.blockHash) || transaction.blockNumber !== receipt.blockNumber ||
+            !index(receipt.transactionIndex) || transaction.transactionIndex !== receipt.transactionIndex ||
+            receipt.gasUsed > expected.gas || receipt.effectiveGasPrice > expected.maxFeePerGas)
+            refuseNative('NATIVE_ACCOUNT_TRANSACTION_MISMATCH', 'Receipt identity or gas accounting differs from the durable transaction');
+        sealed(await pub.getBlock({ blockNumber: receipt.blockNumber }), receipt.blockNumber, receipt.blockHash);
+        let finalized;
+        if (finality === 'finalized') {
+            finalized = await pub.getBlock({ blockTag: 'finalized' });
+            if (!finalized || !uint(finalized.number) || !NATIVE_ACCOUNT_HASH.safeParse(finalized.hash).success)
+                refuseNative('NATIVE_ACCOUNT_TRANSACTION_UNKNOWN', 'Finalized block is unavailable or unsealed');
+            if (finalized.number < receipt.blockNumber)
+                refuseNative('NATIVE_ACCOUNT_NOT_FINAL', 'Transaction is mined but not yet covered by the finalized head');
+            if (finalized.number === receipt.blockNumber && !same(finalized.hash, receipt.blockHash))
+                refuseNative('NATIVE_ACCOUNT_TRANSACTION_MISMATCH', 'Finalized block disagrees with the receipt block');
+        }
+        // Recheck the canonical anchors after collecting finality, as the native settlement reader does.
+        const [anchor, chainId, finalAnchor] = await Promise.all([
+            pub.getBlock({ blockNumber: receipt.blockNumber }), pub.getChainId(),
+            finalized ? pub.getBlock({ blockNumber: finalized.number }) : Promise.resolve(undefined),
+        ]);
+        checkChain(pub, chainId, expected.chainId);
+        sealed(anchor, receipt.blockNumber, receipt.blockHash);
+        if (finalized) {
+            if (!finalAnchor)
+                refuseNative('NATIVE_ACCOUNT_TRANSACTION_UNKNOWN', 'Finalized block could not be rechecked');
+            sealed(finalAnchor, finalized.number, finalized.hash);
+        }
+        return Object.freeze(observed.data);
+    }
+    catch (error) {
+        if (error instanceof NativeYieldRefusal)
+            throw error;
+        return refuseNative('NATIVE_ACCOUNT_TRANSACTION_UNKNOWN', 'Canonical transaction evidence could not be established');
+    }
+}
+//# sourceMappingURL=native-yield-account-rpc.js.map