otto-intel-mcp 0.1.2 → 0.1.4

package/dist/execution-sponsored-settlement.js

@@ -0,0 +1,88 @@
+import { decodeEventLog, keccak256, parseAbi } from 'viem';
+import { sponsoredPlan, sponsoredOutputToken } from './execution-sponsored-definition.js';
+import { DEFAULT_OTTO_LIFI_FEE_RECIPIENT } from './execution-config.js';
+const ABI = parseAbi([
+    'event UserOperationEvent(bytes32 indexed userOpHash,address indexed sender,address indexed paymaster,uint256 nonce,bool success,uint256 actualGasCost,uint256 actualGasUsed)',
+    'event BeforeExecution()',
+    'event Transfer(address indexed from,address indexed to,uint256 value)',
+    'function allowance(address owner,address spender) view returns(uint256)',
+]);
+function fail() { throw new Error('SPONSOR_SETTLEMENT_UNCONFIRMED'); }
+/** Isolate execution logs belonging to this UserOp, excluding every other operation in its bundle. */
+export function sponsoredOperationLogs(receipt, entryPoint, userOpHash) {
+    let start = -1, end = -1;
+    for (const [index, log] of receipt.logs.entries()) {
+        if (log.address.toLowerCase() !== entryPoint.toLowerCase())
+            continue;
+        let decoded;
+        try {
+            decoded = decodeEventLog({ abi: ABI, data: log.data, topics: log.topics, strict: true });
+        }
+        catch {
+            continue;
+        }
+        if (decoded.eventName === 'UserOperationEvent') {
+            if (decoded.args.userOpHash.toLowerCase() === userOpHash.toLowerCase()) {
+                if (end !== -1)
+                    return fail();
+                end = index;
+            }
+            else if (end === -1)
+                start = index;
+        }
+        else if (decoded.eventName === 'BeforeExecution' && end === -1)
+            start = index;
+    }
+    if (start === -1 || end <= start)
+        return fail();
+    return receipt.logs.slice(start + 1, end);
+}
+export async function readSponsoredSwapSettlement(operation, confirmed, client) {
+    const plan = sponsoredPlan(operation.context), terms = operation.context.activation.chains.find(c => c.chainId === operation.context.chainId);
+    const output = sponsoredOutputToken(operation.context.activation, operation.context.chainId, plan.outputToken);
+    const receipt = await client.getTransactionReceipt({ hash: confirmed.transactionHash });
+    if (receipt.transactionHash !== confirmed.transactionHash || receipt.blockHash !== confirmed.blockHash ||
+        receipt.blockNumber.toString() !== confirmed.blockNumber)
+        return fail();
+    let inputDebited = 0n, outputReceived = 0n, ottoFeeReceived = 0n;
+    const owner = operation.context.account.toLowerCase();
+    for (const log of sponsoredOperationLogs(receipt, terms.entryPoint, confirmed.userOpHash)) {
+        if (log.removed || log.transactionHash !== receipt.transactionHash || log.blockHash !== receipt.blockHash || log.blockNumber !== receipt.blockNumber)
+            return fail();
+        let transfer;
+        try {
+            transfer = decodeEventLog({ abi: ABI, data: log.data, topics: log.topics, strict: true });
+        }
+        catch {
+            continue;
+        }
+        if (transfer.eventName !== 'Transfer')
+            continue;
+        const { from, to, value } = transfer.args;
+        if (log.address.toLowerCase() === plan.token.toLowerCase()) {
+            if (from.toLowerCase() === owner)
+                inputDebited += value;
+            if (to.toLowerCase() === owner)
+                inputDebited -= value;
+            if (to.toLowerCase() === DEFAULT_OTTO_LIFI_FEE_RECIPIENT.toLowerCase())
+                ottoFeeReceived += value;
+        }
+        if (log.address.toLowerCase() === plan.outputToken.toLowerCase()) {
+            if (to.toLowerCase() === owner)
+                outputReceived += value;
+            if (from.toLowerCase() === owner)
+                outputReceived -= value;
+        }
+    }
+    const allowance = await client.readContract({ address: plan.token, abi: ABI, functionName: 'allowance',
+        args: [operation.context.account, plan.spender], blockNumber: receipt.blockNumber });
+    const outputCode = await client.getCode({ address: output.address, blockNumber: receipt.blockNumber });
+    if (inputDebited !== plan.gross || outputReceived < plan.minAmountOut || ottoFeeReceived < plan.ottoFee || allowance !== 0n ||
+        !outputCode || outputCode === '0x' || keccak256(outputCode).toLowerCase() !== output.codeHash.toLowerCase() ||
+        await client.getChainId() !== operation.context.chainId || (await client.getBlock({ blockNumber: receipt.blockNumber })).hash !== receipt.blockHash)
+        return fail();
+    return { inputToken: plan.token, outputToken: plan.outputToken, inputDebited: inputDebited.toString(),
+        outputReceived: outputReceived.toString(), ottoFeeReceived: ottoFeeReceived.toString(), allowanceAfter: '0',
+        userOpHash: confirmed.userOpHash, transactionHash: confirmed.transactionHash };
+}
+//# sourceMappingURL=execution-sponsored-settlement.js.map

package/dist/execution-sponsored-store.d.ts

@@ -0,0 +1,67 @@
+import { type AccountGasFailure } from './execution-account-gas-view.js';
+import { type AccountGasReview } from './execution-account-gas-review.js';
+import { type ExecutionJournalDatabase } from './execution-journal-schema.js';
+import { type SponsoredOperation, type SponsoredAuthority } from './execution-sponsored-definition.js';
+import { type PreparedSponsoredRequest, type SponsoredAcknowledgement } from './execution-sponsored-transport.js';
+import type { ConfirmedSponsoredReceipt } from './execution-sponsored-receipt.js';
+import { type NativeUserOpOperation } from './native-yield-userop-operation.js';
+import { type LpUserOpOperation } from './lp-userop-operation.js';
+import { type LpUserOpSubmitEvidence } from './lp-userop.js';
+type SponsoredRecord = SponsoredOperation | NativeUserOpOperation | LpUserOpOperation;
+declare const handoffProofBrand: unique symbol;
+/** Process-local evidence of a committed stamp whose provider start has not been invoked. */
+export interface SponsoredHandoffProof {
+    readonly [handoffProofBrand]: true;
+}
+export declare function validateSponsoredOperation(raw: unknown): SponsoredOperation;
+export declare class SponsoredOperationStore<T extends SponsoredRecord = SponsoredOperation> {
+    readonly db: ExecutionJournalDatabase;
+    private readonly now;
+    private readonly kind;
+    private readonly handoffProofs;
+    constructor(db: ExecutionJournalDatabase, now?: () => number, kind?: 'swap' | 'native-yield-userop' | 'lp-collect-userop');
+    /** Typed view of the SAME connection, table, transaction, cross-rail claim and gas budget. */
+    forNativeYieldUserOp(): SponsoredOperationStore<NativeUserOpOperation>;
+    forLpV3CollectUserOp(): SponsoredOperationStore<LpUserOpOperation>;
+    private narrow;
+    journalStatus(): import("./execution-journal-schema.js").ExecutionJournalStatus;
+    assertReadyForNewOperations(): void;
+    transaction<T>(fn: () => T): T;
+    private decode;
+    private all;
+    private assertContextBudgetAvailable;
+    /** Also checks reviews admitted before another user's proven provider-cap breach. */
+    assertBudgetAvailable(userId: string, operationId: string): void;
+    /** Linearize a transport handoff with every durable gas-cap breach. The callback starts
+     * fetch synchronously and returns its promise; this transaction never awaits the network. */
+    handoff<T>(userId: string, operationId: string, start: () => Promise<T>): Promise<T>;
+    private requireClaim;
+    read(userId: string, operationId: string): T;
+    private save;
+    create(raw: T['context']): T;
+    /** Re-price only an unconsumed review or an exact, terminal proof that no request started.
+     * The same operation ID remains the recovery identity; changed gas terms require new consent. */
+    reviewGas(userId: string, operationId: string, expectedReviewCommitment: string, raw: AccountGasReview): T;
+    recordGasReviewFailure(userId: string, operationId: string, failure: AccountGasFailure): T;
+    begin(userId: string, operationId: string, reviewCommitment: string, authority: SponsoredAuthority): T;
+    prepare(userId: string, operationId: string, request: PreparedSponsoredRequest): T;
+    /** Write the final independent submit baseline once, before the durable attempted stamp and fetch. */
+    recordLpVerification(userId: string, operationId: string, raw: LpUserOpSubmitEvidence): T;
+    attempted(userId: string, operationId: string): T;
+    /** Only a successfully committed standalone stamp can mint this one-use process proof.
+     * Losing it on crash/restart deliberately leaves the original attempted claim unresolved. */
+    attemptedWithProof(userId: string, operationId: string): SponsoredHandoffProof;
+    private uninvokedHandoff;
+    /** Called under handoff's writer lock immediately BEFORE the actual provider callback.
+     * A synchronous callback throw is therefore ambiguous and can never release the claim. */
+    consumeHandoffProof(proof: SponsoredHandoffProof): void;
+    /** Same-process, exact-row non-invocation is the sole exception to retaining a stamped claim. */
+    failUninvokedHandoff(proof: SponsoredHandoffProof): T;
+    acknowledged(userId: string, operationId: string, result: SponsoredAcknowledgement): T;
+    failBeforeHandoff(userId: string, operationId: string): T;
+    recordGasCapBreach(userId: string, operationId: string, receipt: ConfirmedSponsoredReceipt): T;
+    finish(userId: string, operationId: string, receipt: ConfirmedSponsoredReceipt, settlement?: unknown): T;
+}
+/** Does not initialize or migrate: the coordinated offline rollout must already have installed v4. */
+export declare function openSponsoredOperationStore(root: string, now?: () => number): Promise<SponsoredOperationStore>;
+export {};