otto-intel-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 otto AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,102 @@
+# otto Intel MCP
+
+Read-only pre-trade intelligence over MCP, from one shared tool catalog:
+
+- Hosted Streamable HTTP at `https://mcp.ottoai.services`: one successful call free per observed network origin, then pay per call in USDC (x402) — your agent brings its wallet. Its `otto_catalog` storefront tool is always free.
+- Local stdio package (`npx otto-intel-mcp`). The operator's dedicated payer wallet settles each allowlisted data call over x402.
+
+The stdio transport exposes no fund-moving tool. The hosted transport is read-only by default; when the operator arms the execution tools (`OTTO_EXECUTION_MCP_ENABLED=true`) it also serves four **prepare-only** constructors (swap, bridge, Polymarket order, perp order — unsigned plans handed back to the caller's own custody), and when it additionally holds Otto's CDP developer credentials it serves ONE tool that submits: `otto_submit_under_delegation` (below), under the end user's own CDP delegation, server-to-server only. Nothing here holds a user key.
+
+## Tool catalog
+
+| Tool                            | Argument             | x402 price |
+| ------------------------------- | -------------------- | ---------: |
+| `otto_tokenized_equities`       | optional `thesis`    |     $0.001 |
+| `otto_rh_season`                | none                 |     $0.001 |
+| `otto_equity_intel`             | `ticker`             |     $0.003 |
+| `otto_insider_trades`           | `ticker`             |     $0.003 |
+| `otto_institutional_holdings`   | `manager` CIK/ticker |     $0.003 |
+| `otto_equity_smart_money`       | `ticker`             |     $0.006 |
+| `otto_equity_smart_money_brief` | `ticker`             |      $0.10 |
+| `otto_base_season`              | none                 |     $0.002 |
+| `otto_pm_markets`               | none                 |     $0.001 |
+| `otto_pm_crypto`                | none                 |     $0.001 |
+
+The hosted transport also exposes `otto_catalog`. It derives the complete live x402 menu and count from `/.well-known/x402` plus `/llm.txt`; it never consumes the free intelligence call and never requires payment. The ten intelligence prices above mirror the canonical x402 catalog and are parity-tested.
+
+The stdio client accepts only the official otto x402 origin, the Base network, canonical Base USDC, and a per-tool amount at or below the ceiling above. Redirects are disabled.
+
+## Local stdio package
+
+> Unpublished today (`"private": true`; see `publishGate` in `package.json`): the `npx` lines below describe the shape after the first publish. Until then run it from the repo (`npm run dev:stdio`) or from a local `npm pack` tarball.
+
+Use a fresh payer wallet that holds only the Base USDC intended for data calls. Never use a primary wallet.
+
+```bash
+export X402_PRIVATE_KEY=0x...
+npx -y otto-intel-mcp
+```
+
+Example MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "otto-intel": {
+      "command": "npx",
+      "args": ["-y", "otto-intel-mcp"],
+      "env": {
+        "X402_PRIVATE_KEY": "${X402_PRIVATE_KEY}"
+      }
+    }
+  }
+}
+```
+
+The private key stays in the local MCP process. It is used only to authorize bounded x402 data payments; it is never sent to otto.
+
+## Hosted service
+
+Connect a Streamable HTTP MCP client to `https://mcp.ottoai.services`. One successful intelligence call is free per observed network origin. Changing caller-supplied session IDs or client metadata does not create another grant; callers sharing one outbound address also share the courtesy call.
+
+Later unpaid calls return the paid route's machine-actionable, recoverable Base-USDC EIP-3009 requirement. The wrapper also supplies an exact `command`, tool-specific `why_paid`, the shared `pricing_model`, honest `free_call` state, and an `otto_catalog` pointer. Retry the same tool with the signed payload in `x_payment`. The public x402 endpoint remains the verifier and settler, and the hosted process releases a paid payload only when that endpoint returns its settlement receipt.
+
+If an input has no free result, the call returns promptly with the paid route's x402 requirement and the free grant remains available for an input that can be served free. The paid route covers inputs it has never served before. After an interrupted delivery, retry the exact same input with the same signed payload: the durable rail replays its settled response without a second settlement, or completes the attempt if it remained uncharged.
+
+A successfully delivered or recovered paid call carries the route's settlement receipt in the result metadata under `com.ottoai/payment-response` — `{ header, value }`, verbatim, under the header name the paid route used.
+
+The hosted process has no payer wallet or signing key.
+
+For a self-contained transport demo with a mock data source:
+
+```bash
+npm run demo:hosted
+```
+
+## Verification
+
+> Build order: `services/otto-execute` resolves `otto-intel-mcp/adapter` and `otto-intel-mcp/execution` from this package's `dist/` — run `npm run build` here before typechecking or testing otto-execute. Also: `tsc --noEmit` on the FULL tsconfig needs the monorepo (two tests import the sibling `services/x402-router/src/catalog.ts`); the deploy build uses `tsconfig.build.json` (src only), so an isolated Railway build is unaffected.
+
+```bash
+npm run typecheck
+npm test
+npm run build
+```
+
+## Optional CDP SDK (the delegated-send path)
+
+`@coinbase/cdp-sdk` is an **optional dependency**, loaded lazily in exactly two places — `openCdpRig` (`otto-intel-mcp/adapter-cdp`, for a consumer that delegates) and the hosted boot's `openDelegationServicesFromEnv` (`src/execution-delegation.ts`, only when the five delegation variables are set). Importing either adapter entry never resolves it, and a consumer that only verifies or signs with its own key never needs it. The hosted service installs it at its own root, where the `overrides` pin of the SDK's optional `@x402/*` peers to this package's `2.23.0` is honored.
+
+A consumer installing this package gets the SDK too. As of 2026-09-01 this package's own `@x402/axios` + `@x402/evm` are `2.23.0`, which satisfies the SDK's optional `@x402/*@^2.19.0` peers directly — so the graph dedupes to a single `@x402/core@2.23.0` and `npm ls` reports **no** "invalid" marker, with or without the `overrides` pin (npm honors `overrides` in the root project only, so it never reached consumers anyway). The pin is kept, in lockstep, purely for root-install determinism. Install with `--omit=optional` if you do not delegate.
+
+## Delegated send (hosted only) — `otto_submit_under_delegation`
+
+Registers only when the hosted service holds Otto's CDP developer credentials — **five** variables, all or none (partial → boot refuses naming the MISSING names; the SDK absent while configured → named boot refusal; configured while `OTTO_EXECUTION_MCP_ENABLED` is off → boot refuses): `CDP_API_KEY_ID` · `CDP_API_KEY_SECRET` · `CDP_WALLET_SECRET` · `OTTO_DELEGATION_SERVER_SECRET` (≥ 32 chars; the caller presents it in the `x-otto-delegation-auth` request header, never in arguments) · `BASE_RPC_URL` (https). Values are set on Railway by hand, never on Vercel.
+
+**MUST NEVER SCALE ABOVE ONE REPLICA** (`railway.json` `numReplicas: 1`): the fence read-back, the per-user in-flight lock, the per-artifact idempotency record and the signer's rig lock are all process-local. A second replica would allow cross-replica duplicate submissions, nonce races and unsynchronised revocation.
+
+Idempotency: one record per artifact for its freshness window (+10 min grace) — a retry of a SENT artifact replays the stored result (`replayed: true`, nothing re-sent); a HALTED artifact is never retried on this server (the same refusal replays; prepare again); a refusal before any send leaves no record. A record answers only the SAME request: it is bound to a fingerprint over the end user, the envelope's RECOMPUTED whole-envelope commitment (the `artifact_digest` field is never trusted) and the canonical prepare input, so a tampered envelope under a known id is refused (`ARTIFACT_NOT_PREPARED_HERE`) and the same envelope with another user, account or intent is refused (`DELEGATION_REPLAY_MISMATCH`) — a stored success never attests to a plan that was not the one sent. The record is in-process, so the tool submits ONLY artifacts THIS process prepared (`src/prepared-artifacts.ts`: every hosted `otto_prepare_swap` records its `artifact_id`; any other id is refused `ARTIFACT_NOT_PREPARED_HERE` before anything is read). The entry binds the id AND the envelope's whole-envelope commitment, so a re-IDed envelope prepared elsewhere is refused too. That holds across a restart AND across a rolling replacement in which the old and the new process serve at once — the process that did not prepare an artifact cannot know whether the other already sent it, so it refuses. Live entries are never evicted (an issued artifact must always find its record); the registry is bounded by refusing a NEW prepare at 100,000 live entries (`PREPARED_ARTIFACT_CAPACITY`). That refusal is unreachable in practice — an entry lives for the artifact's freshness window plus the 10-minute grace (≈ 15 minutes), so 100,000 live entries means ≈ 110 sustained prepares per second on this service against a per-identity prepare rate limit of 10 per minute by default; it exists so the bound is honest, and it must NEVER be "fixed" into evicting a live entry, which would refuse an issued artifact instead of replaying it. Consequence, by design: an agent whose prepare → submit spans a deploy is refused and prepares again (rare; fail-closed). Refusals carry cause classes, never upstream error text; boot failures print fixed text with URLs and configured secret values redacted (`src/boot-redaction.ts`).
+
+**Delegation admin tools (hosted only, same header, same admission):** `otto_delegation_fence` — the ONLY writer of the Model-B project policy: ensure-by-digest + read-back. Rules, each mutation-proved: EXACTLY ONE project-scope policy or refuse (`DELEGATION_FENCE_AMBIGUOUS` — Coinbase allows one; more is an anomalous snapshot, never judged, never written to; the send tool's read-back refuses it too); a policy is Otto's own only when its description matches `^OTTO model b swap fence v<N>$` exactly — N ≤ this server's version with stale rules → updated IN PLACE, N newer → refused (`DELEGATION_FENCE_NEWER`, never downgraded), anything else → refused BY NAME (`DELEGATION_FENCE_FOREIGN`; never overwritten, never deleted); a create Coinbase refuses as a duplicate is never retried (re-read once, judge what is there); before an update the policy is re-read by id and must still be exactly the snapshot; after any write the proof is a read-back of exactly one policy whose id IS the written id and which is v-current (a bounded poll, then fail-closed). **Operational premise (no conditional update in `@coinbase/cdp-sdk` 1.54.0 — `UpdatePolicyOptions` carries no revision/ETag):** AT MOST ONE ENSURE WRITES PROJECT-WIDE AT A TIME, ACROSS VERSIONS — the ensure is an ops action run by one operator (the seat or the Founder, with the server secret), never during a rolling deploy (two versions of the tool running at once are two writers and the older one would win a race and downgrade), never from the dApp (PR-2's mint gate reads `fence.present` from `otto_delegation_status`), and nobody edits the policy in the CDP portal while it runs. Under that premise the pre-write re-read is exact — without it, "never overwrite foreign" and "never downgrade" narrow to "…what was foreign / newer one round-trip ago". `otto_delegation_status` — `{ accessToken }` only: the server resolves the end user through `cdp.endUser.validateAccessToken`; a client-sent user id is refused; the output is bound to that user. `otto_delegation_revoke` — `{ accessToken }` (user path) OR `{ userId, support_reason }` (support path, for an operator holding the server secret; the reason is logged through the boot redactor — URLs and configured secret values never land in the log — a token never is); developer-side revoke confirmed by read-back, and this server submits nothing for the user afterwards even if the read-back failed. `otto_delegation_fence_status` — PUBLIC and read-only, no header: the fence's public promise (`present`, versioned name, rules digest, per-swap cap USD; a `reason` class when absent) — never a user, a grant, an address or a policy's contents; `otto-execute delegate` reads it before minting. With delegation configured the hosted tool count is 21.
+
+Residual (spec-level, not this tool's): the MCP SDK requires `params.arguments` to be PRESENT and an OBJECT before any handler runs (the request schema, then the registered object schema), so an absent `arguments`, `null`, an array or a primitive is answered by the SDK's `InvalidParams` error whether or not the caller is authenticated — an objectness/presence oracle every MCP server has. The tool's own field schema is validated only after the caller header is accepted; the SDK's error carries no secret and no field name (asserted in `test/hosted-delegation.test.ts`). The fence and its residual are stated in `src/execution-delegation-policy.ts`.

package/dist/adapter/cdp-signer.d.ts

@@ -0,0 +1,133 @@
+/**
+ * cdp-signer.ts — the CDP-delegated capability provider, product-shaped.
+ *
+ * The end user has ALREADY signed in and minted a time-boxed delegation somewhere else (a dApp, the
+ * proof kit's OTP flow, …). This adapter holds Otto's developer-side CDP access and submits the
+ * user's OWN transactions under that delegation: user-authenticated, Otto-governed (the project policy
+ * is the fence), Otto-revocable. It never holds a user key, never mints a grant, and submits ONLY a
+ * plan that `assertPlanSignableBy` accepts for THIS user.
+ *
+ * RUNTIME privacy, not TypeScript privacy: the raw "send this unsigned transaction under the user's
+ * delegation" capability lives in a module-private WeakMap keyed by the rig object. A `CdpRig` value
+ * exposes only chain reads, delegation read-back and revocation; the signer reaches the raw send
+ * through the WeakMap, and its own submission path is a `#private` method. Nothing reachable from a
+ * rig or a signer can submit an unverified transaction.
+ *
+ * Lifecycle serialization lives on the RIG, not on the signer: `sendPlan`, its allowance clear, the
+ * signer's `revokeDeveloperSide` AND the rig's public `revoke` all run through one module-private lock
+ * per rig, so a revocation issued by anyone holding the rig can never race an in-flight plan or its
+ * cleanup. Revocation is a FAIL-CLOSED per-user transition: the lock is held through the raw revoke AND
+ * its read-back, and once revocation has been REQUESTED for a user on a rig, no plan for that user is
+ * ever submitted on that rig again — confirmed, unconfirmed or failed. A halted plan's clear is
+ * confirmed by an `allowance` read-back, never inferred from a receipt.
+ *
+ * Nonce, gas and serialization are adapter-owned (spec §6): the unsigned EIP-1559 transaction is
+ * assembled here from chain reads and handed to CDP to sign and broadcast.
+ */
+import { type Address, type Hex, type PublicClient } from 'viem';
+import { type SealedWaitOptions } from './chain.js';
+import type { SentStep } from './sent-step.js';
+import { type SigningCapability, type VerifiedSwap } from './verify.js';
+export declare const CDP_CAPABILITIES: readonly SigningCapability[];
+export declare const CHAIN_ID: 8453;
+export declare const NETWORK: "base";
+export interface CdpDeveloperCredentials {
+    readonly apiKeyId: string;
+    readonly apiKeySecret: string;
+    readonly walletSecret: string;
+}
+export interface CdpEndUser {
+    readonly userId: string;
+    readonly address: Address;
+}
+/** The PUBLIC face of a rig: chain reads, delegation read-back, revocation. No submission surface. */
+export interface CdpRig {
+    readonly pub: PublicClient;
+    readDelegation(userId: string): Promise<{
+        expiresAt: string;
+    } | undefined>;
+    /**
+     * Request revocation and confirm it by read-back, serialized with every plan on this rig. Resolves
+     * only once the grant no longer reads back; rejects if it still does. Either way the user is marked
+     * revocation-requested on this rig and no later plan for them is submitted (fail-closed).
+     */
+    revoke(userId: string): Promise<void>;
+}
+/** The raw capabilities a rig is built from. Held privately by this module once the rig exists. */
+export interface CdpRawOperations {
+    readonly pub: PublicClient;
+    /** Sign + broadcast an unsigned serialized EIP-1559 transaction under the user's delegation. Returns the tx hash. */
+    submit(user: CdpEndUser, unsignedTransaction: Hex): Promise<Hex>;
+    revoke(userId: string): Promise<void>;
+    readDelegation(userId: string): Promise<{
+        expiresAt: string;
+    } | undefined>;
+}
+/** True once `rig.revoke(userId)` has been called on this rig, whatever it returned. */
+export declare function revocationRequested(rig: CdpRig, userId: string): boolean;
+/**
+ * Why a delegated plan halted — a closed vocabulary the signer sets from STRUCTURED facts only (the CDP
+ * `errorType`, an error's class, the receipt status, its own checks). Message text never selects it, so
+ * upstream text cannot steer the class a consumer reports.
+ */
+export type DelegatedHaltCause = 'policy_violation' | 'delegation_not_active' | 'artifact_no_longer_signable' | 'reverted' | 'receipt_not_sealed' | 'upstream_failure';
+/**
+ * A delegated plan halted; `cause` is the structured class above, `allowanceCleared` says whether the
+ * router allowance is known to be zero again. The message is for the operator; a consumer that must not
+ * relay upstream text reads `cause` and the two fields only.
+ */
+export declare class DelegatedPlanHaltedError extends Error {
+    readonly failedStep: number;
+    readonly allowanceCleared: boolean;
+    readonly cause: DelegatedHaltCause;
+    readonly clearTransactionHash?: Hex | undefined;
+    constructor(message: string, failedStep: number, allowanceCleared: boolean, cause: DelegatedHaltCause, clearTransactionHash?: Hex | undefined);
+}
+/** Thrown by the signer itself once revocation was requested for the user on this rig (fail-closed). */
+export declare class RevocationRequestedError extends Error {
+    constructor(userId: string);
+}
+/** Classify a failure from its STRUCTURE (class, `errorType`) — never from its message text. */
+export declare function haltCauseOf(error: unknown): DelegatedHaltCause;
+/**
+ * Build a rig from raw operations. The raw operations are captured into the module-private registry;
+ * the returned object exposes only reads and revocation. (Callers who hold a CDP client already have
+ * the raw capability — this function does not create it, it fences it.)
+ */
+export declare function createCdpRig(raw: CdpRawOperations): CdpRig;
+/** Open a rig with Otto's developer credentials against Base mainnet. */
+export declare function openCdpRig(credentials: CdpDeveloperCredentials, rpcUrl?: string): Promise<CdpRig>;
+/**
+ * Revoke by `userId` alone, with read-back — usable even when the delegation request's response was
+ * lost (the grant may have committed remotely). Resolves only once the grant no longer reads back.
+ * This IS `rig.revoke`: serialized on the rig, lock held through the read-back, fail-closed afterwards.
+ */
+export declare function revokeDelegationByUserId(rig: CdpRig, userId: string): Promise<void>;
+export declare class CdpDelegatedSigner {
+    #private;
+    readonly capabilities: readonly SigningCapability[];
+    readonly chainId: 8453;
+    constructor(rig: CdpRig, user: CdpEndUser, options?: {
+        readonly sealedWait?: SealedWaitOptions;
+    });
+    get address(): Address;
+    get user(): CdpEndUser;
+    /**
+     * `send_evm_transaction`, under delegation: only a plan `assertPlanSignableBy` accepts for THIS user,
+     * re-checked before every step AND again immediately before each hand-off to CDP (after the nonce /
+     * fee / gas round trips, so an artifact that expires during preparation is never submitted). The plan
+     * halts at the first step that does not succeed; after ANY failure a bounded `approve(spender, 0)` is
+     * attempted under the same policy and its real outcome — confirmed by an allowance read-back — is
+     * reported. A failed reset may leave a pre-existing allowance, so step 0 is not exempt.
+     */
+    sendPlan(plan: VerifiedSwap): Promise<SentStep[]>;
+    /**
+     * The Otto-side kill switch, with read-back. Serialized on the rig (waits for any in-flight plan and
+     * its cleanup, holds the lock through the read-back) and fail-closed: no later plan for this user
+     * is submitted on this rig, whatever the read-back said.
+     */
+    revokeDeveloperSide(): Promise<void>;
+    delegation(): Promise<{
+        expiresAt: string;
+    } | undefined>;
+}

package/dist/adapter/cdp-signer.js

@@ -0,0 +1,356 @@
+/**
+ * cdp-signer.ts — the CDP-delegated capability provider, product-shaped.
+ *
+ * The end user has ALREADY signed in and minted a time-boxed delegation somewhere else (a dApp, the
+ * proof kit's OTP flow, …). This adapter holds Otto's developer-side CDP access and submits the
+ * user's OWN transactions under that delegation: user-authenticated, Otto-governed (the project policy
+ * is the fence), Otto-revocable. It never holds a user key, never mints a grant, and submits ONLY a
+ * plan that `assertPlanSignableBy` accepts for THIS user.
+ *
+ * RUNTIME privacy, not TypeScript privacy: the raw "send this unsigned transaction under the user's
+ * delegation" capability lives in a module-private WeakMap keyed by the rig object. A `CdpRig` value
+ * exposes only chain reads, delegation read-back and revocation; the signer reaches the raw send
+ * through the WeakMap, and its own submission path is a `#private` method. Nothing reachable from a
+ * rig or a signer can submit an unverified transaction.
+ *
+ * Lifecycle serialization lives on the RIG, not on the signer: `sendPlan`, its allowance clear, the
+ * signer's `revokeDeveloperSide` AND the rig's public `revoke` all run through one module-private lock
+ * per rig, so a revocation issued by anyone holding the rig can never race an in-flight plan or its
+ * cleanup. Revocation is a FAIL-CLOSED per-user transition: the lock is held through the raw revoke AND
+ * its read-back, and once revocation has been REQUESTED for a user on a rig, no plan for that user is
+ * ever submitted on that rig again — confirmed, unconfirmed or failed. A halted plan's clear is
+ * confirmed by an `allowance` read-back, never inferred from a receipt.
+ *
+ * Nonce, gas and serialization are adapter-owned (spec §6): the unsigned EIP-1559 transaction is
+ * assembled here from chain reads and handed to CDP to sign and broadcast.
+ */
+import { createPublicClient, encodeFunctionData, http, serializeTransaction, } from 'viem';
+import { base } from 'viem/chains';
+import { SealedReceiptTimeoutError, waitForSealedReceipt } from './chain.js';
+import { ERC20_APPROVE_ABI, readAllowance } from './erc20.js';
+import { isAdapterRefusal } from './refusal.js';
+import { assertPlanSignableBy } from './verify.js';
+export const CDP_CAPABILITIES = Object.freeze(['send_evm_transaction']);
+export const CHAIN_ID = 8453;
+export const NETWORK = 'base';
+const RAW = new WeakMap();
+/** One lifecycle lock PER RIG — shared by every signer over it and by the rig's own public `revoke`. */
+const LOCKS = new WeakMap();
+/** Per rig: the users whose revocation has been REQUESTED (set before the raw revoke is issued; never cleared). */
+const REVOKE_REQUESTED = new WeakMap();
+/** True once `rig.revoke(userId)` has been called on this rig, whatever it returned. */
+export function revocationRequested(rig, userId) {
+    return REVOKE_REQUESTED.get(rig)?.has(userId) ?? false;
+}
+/** Run `operation` after everything previously queued on this rig has settled; nothing else starts until it settles. */
+function serializedOn(rig, operation) {
+    const lock = LOCKS.get(rig);
+    if (!lock)
+        throw new Error('rig was not created by openCdpRig/createCdpRig');
+    const run = lock.chain.then(operation, operation);
+    lock.chain = run.catch(() => undefined);
+    return run;
+}
+/**
+ * A delegated plan halted; `cause` is the structured class above, `allowanceCleared` says whether the
+ * router allowance is known to be zero again. The message is for the operator; a consumer that must not
+ * relay upstream text reads `cause` and the two fields only.
+ */
+export class DelegatedPlanHaltedError extends Error {
+    failedStep;
+    allowanceCleared;
+    cause;
+    clearTransactionHash;
+    constructor(message, failedStep, allowanceCleared, cause, clearTransactionHash) {
+        super(message);
+        this.failedStep = failedStep;
+        this.allowanceCleared = allowanceCleared;
+        this.cause = cause;
+        this.clearTransactionHash = clearTransactionHash;
+        this.name = 'DelegatedPlanHaltedError';
+    }
+}
+/** Thrown by the signer itself once revocation was requested for the user on this rig (fail-closed). */
+export class RevocationRequestedError extends Error {
+    constructor(userId) {
+        super(`refusing to submit: delegation revocation was requested for ${userId} on this rig`);
+        this.name = 'RevocationRequestedError';
+    }
+}
+const ABSENT_DELEGATION_ERROR_TYPES = ['delegation_not_found', 'delegation_revoked', 'delegation_expired'];
+/** Classify a failure from its STRUCTURE (class, `errorType`) — never from its message text. */
+export function haltCauseOf(error) {
+    if (error instanceof RevocationRequestedError)
+        return 'delegation_not_active';
+    if (error instanceof SealedReceiptTimeoutError)
+        return 'receipt_not_sealed';
+    if (isAdapterRefusal(error))
+        return 'artifact_no_longer_signable';
+    const errorType = error?.errorType;
+    if (errorType === 'policy_violation')
+        return 'policy_violation';
+    if (typeof errorType === 'string' && ABSENT_DELEGATION_ERROR_TYPES.includes(errorType))
+        return 'delegation_not_active';
+    return 'upstream_failure';
+}
+function isAbsentDelegation(error) {
+    const e = error;
+    return e.statusCode === 404 || ABSENT_DELEGATION_ERROR_TYPES.includes(e.errorType ?? '');
+}
+/**
+ * Build a rig from raw operations. The raw operations are captured into the module-private registry;
+ * the returned object exposes only reads and revocation. (Callers who hold a CDP client already have
+ * the raw capability — this function does not create it, it fences it.)
+ */
+export function createCdpRig(raw) {
+    const requested = new Set();
+    const rig = Object.freeze({
+        pub: raw.pub,
+        readDelegation: (userId) => raw.readDelegation(userId),
+        // The public revocation goes through the rig's lifecycle lock and HOLDS it through the read-back:
+        // it lands only after any in-flight plan on this rig and its allowance clear have settled, and a
+        // plan queued behind it runs only after the read-back — where it is refused, because the user was
+        // marked revocation-requested BEFORE the raw revoke was issued.
+        revoke: (userId) => serializedOn(rig, async () => {
+            requested.add(userId);
+            try {
+                await raw.revoke(userId);
+            }
+            catch {
+                // A grant that never existed (or is already gone) reads back as absent below; other failures surface there.
+            }
+            const after = await raw.readDelegation(userId);
+            if (after)
+                throw new Error(`delegation for ${userId} still reads back after revoke (expires ${after.expiresAt})`);
+        }),
+    });
+    RAW.set(rig, raw);
+    LOCKS.set(rig, { chain: Promise.resolve() });
+    REVOKE_REQUESTED.set(rig, requested);
+    return rig;
+}
+/**
+ * `@coinbase/cdp-sdk` is an OPTIONAL dependency of this package, loaded here and only here: an install
+ * that never delegates does not need it, and a consumer that does gets a named failure instead of a
+ * module-resolution stack when it is missing.
+ */
+async function loadCdpSdk() {
+    try {
+        return await import('@coinbase/cdp-sdk');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`@coinbase/cdp-sdk is not installed: the delegated signer needs the optional dependency (${reason})`);
+    }
+}
+/** Open a rig with Otto's developer credentials against Base mainnet. */
+export async function openCdpRig(credentials, rpcUrl) {
+    const { CdpClient } = await loadCdpSdk();
+    const cdp = new CdpClient({
+        apiKeyId: credentials.apiKeyId,
+        apiKeySecret: credentials.apiKeySecret,
+        walletSecret: credentials.walletSecret,
+    });
+    const pub = createPublicClient({ chain: base, transport: http(rpcUrl) });
+    let chainId;
+    try {
+        chainId = await pub.getChainId();
+    }
+    catch {
+        // FIXED text: viem's own message carries the RPC URL (a key may ride in its path); it is never rethrown.
+        throw new Error('the RPC endpoint did not answer eth_chainId; refusing to open the rig');
+    }
+    if (chainId !== CHAIN_ID)
+        throw new Error(`RPC reports chainId ${chainId}, expected ${CHAIN_ID} (Base mainnet)`);
+    return createCdpRig({
+        pub,
+        submit: async (user, transaction) => {
+            const result = await cdp.endUser.sendEvmTransaction({ userId: user.userId, address: user.address, transaction, network: NETWORK });
+            return result.transactionHash;
+        },
+        revoke: async (userId) => {
+            await cdp.endUser.revokeDelegationForEndUser({ userId });
+        },
+        readDelegation: async (userId) => {
+            try {
+                return await cdp.endUser.getDelegationForEndUser({ userId });
+            }
+            catch (error) {
+                if (isAbsentDelegation(error))
+                    return undefined;
+                throw error;
+            }
+        },
+    });
+}
+/**
+ * Revoke by `userId` alone, with read-back — usable even when the delegation request's response was
+ * lost (the grant may have committed remotely). Resolves only once the grant no longer reads back.
+ * This IS `rig.revoke`: serialized on the rig, lock held through the read-back, fail-closed afterwards.
+ */
+export function revokeDelegationByUserId(rig, userId) {
+    return rig.revoke(userId);
+}
+async function buildUnsignedTransaction(pub, from, step) {
+    const [nonce, fees] = await Promise.all([
+        pub.getTransactionCount({ address: from, blockTag: 'pending' }),
+        pub.estimateFeesPerGas(),
+    ]);
+    let gas;
+    try {
+        gas = ((await pub.estimateGas({ account: from, to: step.to, value: step.value, data: step.data })) * 12n) / 10n;
+    }
+    catch {
+        // An out-of-policy transaction is still a valid transaction; a node-side estimate failure must not
+        // be confused with the policy engine refusing. Keep a generous static limit.
+        gas = 400000n;
+    }
+    return serializeTransaction({
+        type: 'eip1559',
+        chainId: CHAIN_ID,
+        nonce,
+        to: step.to,
+        value: step.value,
+        data: step.data,
+        gas,
+        maxFeePerGas: fees.maxFeePerGas,
+        maxPriorityFeePerGas: fees.maxPriorityFeePerGas,
+    });
+}
+export class CdpDelegatedSigner {
+    capabilities = CDP_CAPABILITIES;
+    chainId = CHAIN_ID;
+    #rig;
+    #raw;
+    #user;
+    #sealedWait;
+    constructor(rig, user, options = {}) {
+        const raw = RAW.get(rig);
+        if (!raw)
+            throw new Error('CdpDelegatedSigner needs a rig created by openCdpRig/createCdpRig');
+        this.#rig = rig;
+        this.#raw = raw;
+        this.#user = Object.freeze({ userId: user.userId, address: user.address });
+        this.#sealedWait = options.sealedWait;
+    }
+    get address() {
+        return this.#user.address;
+    }
+    get user() {
+        return this.#user;
+    }
+    /**
+     * Assemble the unsigned transaction from chain reads, run `beforeSubmit` (the plan's freshness /
+     * binding re-check, AFTER the RPC round trips and immediately before the hand-off), then submit.
+     */
+    async #submit(step, beforeSubmit) {
+        const transaction = await buildUnsignedTransaction(this.#raw.pub, this.#user.address, step);
+        beforeSubmit?.();
+        return this.#raw.submit(this.#user, transaction);
+    }
+    /** Fail-closed: once revocation was requested for this user on this rig, nothing is submitted for them again. */
+    #assertNotRevoked() {
+        if (revocationRequested(this.#rig, this.#user.userId))
+            throw new RevocationRequestedError(this.#user.userId);
+    }
+    /**
+     * `send_evm_transaction`, under delegation: only a plan `assertPlanSignableBy` accepts for THIS user,
+     * re-checked before every step AND again immediately before each hand-off to CDP (after the nonce /
+     * fee / gas round trips, so an artifact that expires during preparation is never submitted). The plan
+     * halts at the first step that does not succeed; after ANY failure a bounded `approve(spender, 0)` is
+     * attempted under the same policy and its real outcome — confirmed by an allowance read-back — is
+     * reported. A failed reset may leave a pre-existing allowance, so step 0 is not exempt.
+     */
+    sendPlan(plan) {
+        return serializedOn(this.#rig, async () => {
+            // Entry, inside the lock: a plan queued behind a revocation lands here AFTER the revoke and its
+            // read-back, and is refused before any step — nothing to clear.
+            this.#assertNotRevoked();
+            assertPlanSignableBy(plan, this, Date.now());
+            const out = [];
+            for (const [index, step] of plan.steps.entries()) {
+                try {
+                    this.#assertNotRevoked();
+                    assertPlanSignableBy(plan, this, Date.now());
+                }
+                catch (error) {
+                    throw await this.#halt(plan, index, `plan no longer signable before step ${index}: ${error instanceof Error ? error.message : String(error)}`, haltCauseOf(error));
+                }
+                let hash;
+                let receipt;
+                try {
+                    hash = await this.#submit(step, () => {
+                        this.#assertNotRevoked();
+                        assertPlanSignableBy(plan, this, Date.now());
+                    });
+                    await this.#raw.pub.waitForTransactionReceipt({ hash }); // first sight (may be a preconfirmation) …
+                    // … then only the SEALED, CANONICAL receipt counts: the next step is estimated against sealed state,
+                    // and a preconfirmation omitted from the sealed block is never reported as success.
+                    receipt = await waitForSealedReceipt(this.#raw.pub, hash, this.#sealedWait);
+                }
+                catch (error) {
+                    // The CAUSE is classified from the error's structure (`haltCauseOf`); the message carries the upstream
+                    // text for the operator and is never what a consumer classifies on.
+                    const errorType = error.errorType;
+                    throw await this.#halt(plan, index, `delegated step ${index} (${step.kind}) failed: ${typeof errorType === 'string' && errorType ? `${errorType} | ` : ''}${error instanceof Error ? error.message : String(error)}`, haltCauseOf(error));
+                }
+                if (receipt.status !== 'success') {
+                    throw await this.#halt(plan, index, `delegated step ${index} (${step.kind}) reverted on-chain: ${hash}`, 'reverted');
+                }
+                out.push(Object.freeze({
+                    index,
+                    kind: step.kind,
+                    to: step.to,
+                    transaction_hash: hash,
+                    status: 'success',
+                    block_number: receipt.blockNumber.toString(),
+                    gas_used: receipt.gasUsed.toString(),
+                }));
+            }
+            return out;
+        });
+    }
+    /**
+     * After ANY failure: attempt `approve(spender, 0)` under the delegation, then READ the allowance back.
+     * `allowanceCleared` is true only when the read-back is zero — a mined clear whose read-back is not
+     * zero, a reverted clear, a failed submission or a failed read all report false with the hand-off.
+     */
+    async #halt(plan, failedStep, message, cause) {
+        const handOff = `clear approve(${plan.spender}, 0) on ${plan.token} BEFORE revoking the delegation`;
+        let hash;
+        try {
+            hash = await this.#submit({
+                to: plan.token,
+                value: 0n,
+                data: encodeFunctionData({ abi: ERC20_APPROVE_ABI, functionName: 'approve', args: [plan.spender, 0n] }),
+            });
+            await this.#raw.pub.waitForTransactionReceipt({ hash });
+            // The read-back below must see the clear: only its sealed canonical receipt counts.
+            const clearReceipt = await waitForSealedReceipt(this.#raw.pub, hash, this.#sealedWait);
+            if (clearReceipt.status !== 'success') {
+                return new DelegatedPlanHaltedError(`${message}; allowance clear ${hash} reverted — ${handOff}`, failedStep, false, cause, hash);
+            }
+            const remaining = await readAllowance(this.#raw.pub, plan.token, this.#user.address, plan.spender);
+            if (remaining !== 0n) {
+                return new DelegatedPlanHaltedError(`${message}; allowance clear ${hash} was mined but ${remaining} still reads back — ${handOff}`, failedStep, false, cause, hash);
+            }
+            return new DelegatedPlanHaltedError(`${message}; allowance cleared in ${hash} (read-back 0)`, failedStep, true, cause, hash);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            return new DelegatedPlanHaltedError(`${message}; allowance clear ${hash ? `${hash} could not be confirmed` : 'FAILED'} (${reason}) — ${handOff}`, failedStep, false, cause, hash);
+        }
+    }
+    /**
+     * The Otto-side kill switch, with read-back. Serialized on the rig (waits for any in-flight plan and
+     * its cleanup, holds the lock through the read-back) and fail-closed: no later plan for this user
+     * is submitted on this rig, whatever the read-back said.
+     */
+    revokeDeveloperSide() {
+        return this.#rig.revoke(this.#user.userId);
+    }
+    delegation() {
+        return this.#rig.readDelegation(this.#user.userId);
+    }
+}
+//# sourceMappingURL=cdp-signer.js.map

package/dist/adapter/cdp-signer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdp-signer.js","sourceRoot":"","sources":["../../src/adapter/cdp-signer.ts"],"names":[],"mappings":"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"}