otto-intel-mcp 0.1.3 → 0.1.4

package/README.md

@@ -1,9 +1,11 @@
 # Otto Intel MCP
 
-Market intelligence and trade construction for AI agents, over MCP: SEC filings and insider flow for US stocks, tokenized equities on Robinhood Chain, Base and Polymarket market context, plus four **constructors** that build a ready-to-sign swap, bridge, Polymarket order or Hyperliquid perp order for an address you supply. Pay per call in USDC on Base; on the hosted server the first call from your network address is free.
+Market intelligence and trade construction for AI agents, over MCP: SEC filings and insider flow for US stocks, tokenized equities on Robinhood Chain, Base and Polymarket market context, plus **constructors** for swaps, bridges, orders, tokenized-stock purchases and vault deposits or withdrawals. Pay per intelligence call in USDC on Base; on the hosted server the first successful eligible intelligence call from your network address is free.
 
-- Hosted: `https://mcp.ottoai.services` — 22 tools.
-- Local: `npx otto-intel-mcp` — the 10 intelligence tools, paid from a wallet you configure.
+**This source is the staged `otto-intel-mcp@0.1.4` release candidate.** It includes the reviewed Optimism swap verifier and the library entries described below. Publication does not establish hosted deployment or activate native/sponsored/LP execution. The companion `otto-execute@0.1.4` candidate deliberately retains the aged MCP `0.1.3` verifier, so its Optimism EOA path remains refused until a later release repins this package after seven full days from publication.
+
+- Hosted: `https://mcp.ottoai.services` — use `tools/list` to inspect the deployed registry. This source registers 34 tools when fully configured. Registry presence does not enable an execution rail; query its current availability.
+- Local: `npx otto-intel-mcp` — the 13 intelligence tools, paid from a wallet you configure.
 - Docs: https://docs.useotto.xyz/acp-swarm/otto-intel-mcp
 
 ## Quick start (hosted, under a minute)
@@ -27,20 +29,20 @@ claude mcp add otto-intel --transport http https://mcp.ottoai.services
 **First call** — ask your agent, or call the tool directly:
 
 ```text
-Use otto_pm_crypto and summarize the top three markets.
+Use otto_base_season and summarize the returned Base tokens and their freshness.
 ```
 
 ```json
-{ "method": "tools/call", "params": { "name": "otto_pm_crypto", "arguments": {} } }
+{ "method": "tools/call", "params": { "name": "otto_base_season", "arguments": {} } }
 ```
 
 (a standard MCP `tools/call` request — your MCP client wraps it in JSON-RPC and handles `initialize` and the Streamable HTTP session)
 
-That call is free (one per network address). The next one returns a payment request; your agent signs it with an x402 wallet and retries with the signed payload in `x_payment` — see [How paying works](#how-paying-works).
+The first successful eligible cached intelligence call is free for a network address; crypto news is paid-only. Later calls return a payment request; your agent signs it with an x402 wallet and retries with the signed payload in `x_payment` — see [How paying works](#how-paying-works). The [Agent Quickstart](https://docs.useotto.xyz/getting-started/agent-quickstart) includes the complete Base example and receipt checks.
 
 ## Quick start (local)
 
-Runs the 10 intelligence tools on your machine and pays each call from a wallet you provide. It needs one variable, `X402_PRIVATE_KEY` — the key of a wallet holding some USDC on Base.
+Runs the 13 intelligence tools on your machine and pays each call from a wallet you provide. It needs one variable, `X402_PRIVATE_KEY` — the key of a wallet holding some USDC on Base.
 
 **Claude Code**
 
@@ -62,9 +64,9 @@ claude mcp add otto-intel -e X402_PRIVATE_KEY=0x… -- npx -y otto-intel-mcp
 }
 ```
 
-Requires Node 22 or newer. Optional: `X402_RPC_URL` (your own Base RPC), `X402_TIMEOUT_MS` (default 30000). The local server serves the 10 intelligence tools only — **the four constructors are hosted-only**: to get an envelope, call `otto_prepare_swap` on `https://mcp.ottoai.services` (free). A paid local call carries the rail's settlement receipt in the result metadata under `com.ottoai/payment-response`, exactly like the hosted server.
+Requires Node 22 or newer. Optional: `X402_RPC_URL` (your own Base RPC), `X402_TIMEOUT_MS` (default 30000). The local server serves the 13 intelligence tools by default. To get an envelope from the hosted service, call `otto_prepare_swap` on `https://mcp.ottoai.services` (free). A paid local call carries the rail's settlement receipt in the result metadata under `com.ottoai/payment-response`, exactly like the hosted server.
 
-`npm audit` on a fresh install reports findings that all sit in the local server's third-party venue clients (`@polymarket/clob-client-v2` → ethers v5 → `ws`, `@nktkas/hyperliquid` → `valibot`, the optional `@coinbase/cdp-sdk` → an older `axios`), none of which the library entries (`otto-intel-mcp/execution`, `/adapter`, `/adapter-cdp`) or `otto-execute` load — `otto-execute` on its own installs 19 packages with 0 findings. `npm install otto-intel-mcp --omit=optional` drops the Coinbase subtree if you do not delegate.
+Dependency audit results depend on the installed package versions and optional dependencies. The Hyperliquid execution client loads its venue SDK; run `npm audit` against the actual installation when assessing that path. `npm install otto-intel-mcp --omit=optional` drops the optional Coinbase subtree if you do not delegate.
 
 ## What you get
 
@@ -72,6 +74,8 @@ Requires Node 22 or newer. Optional: `X402_RPC_URL` (your own Base RPC), `X402_T
 
 | Tool | Argument | Returns | Price |
 | --- | --- | --- | ---: |
+| `otto_crypto_news` | — | Ranked crypto headlines, source links, publication times and a market brief; paid-only | $0.001 |
+| `otto_news_recaps` | — | Concise market recap, ranked stories, analysis window and freshness | $0.003 |
 | `otto_tokenized_equities` | optional `thesis` | The live registry of US stocks and ETFs tokenized on Robinhood Chain — symbol, token address, reference price, tradability; with a thesis, a ranked shortlist with a match reason per row | $0.001 |
 | `otto_rh_season` | — | Robinhood Chain movers, rug-screened, with per-token risk flags | $0.001 |
 | `otto_equity_intel` | `ticker` | SEC fundamentals for a US ticker: revenue and net-income trend, margins, EPS, leverage, recent 10-K / 10-Q / 8-K filings, and a short summary | $0.003 |
@@ -82,19 +86,26 @@ Requires Node 22 or newer. Optional: `X402_RPC_URL` (your own Base RPC), `X402_T
 | `otto_base_season` | — | Quality-screened Base tokens with current social and trusted-KOL context | $0.002 |
 | `otto_pm_markets` | — | The highest-volume open Polymarket markets: outcome probabilities, bid/ask, liquidity, volume, end dates | $0.001 |
 | `otto_pm_crypto` | — | The same for BTC, ETH and crypto Polymarket markets | $0.001 |
+| `otto_stock_pools` | `stock` (`network:ticker` or `network:address`) | The DEX pools a tokenized US stock or ETF is a member of on Robinhood Chain, Base, BNB Chain or Solana: pool id, DEX and version, which side the asset is on, the counterpart token with an evidence-backed class, reported liquidity and 24h volume, and the coverage limits | $0.001 |
 
 All of these return data and context, not recommendations.
 
+**News access:** `otto_crypto_news` reads ranked headlines and a market brief for $0.001 USDC and is paid-only, preserving your free allowance. `otto_news_recaps` reads a concise recap and ranked stories for $0.003 USDC; a warm cached result can use the free allowance. A cold recap returns the payment challenge without unpaid generation. Both take `{}` (hosted paid retries add `x_payment`). These additions are in this source candidate; check the deployed `tools/list` before calling them.
+
 ### Execution constructors — hosted, free
 
-A constructor builds the transaction; **your wallet signs and sends it.** Give it the address that will sign, and it returns an *envelope*: the ordered steps (for example allowance reset → approval → swap), every check it ran on its own output, a `valid_until`, and a digest so a stale or altered plan is detectable. Otto Intel MCP itself never signs or submits.
+A constructor builds the transaction; **your wallet signs and sends it.** Give it the address that will sign, and it returns an *envelope*: the ordered steps (for example allowance reset → approval → swap), every check it ran on its own output, a `valid_until`, and a digest so a stale or altered plan is detectable. A constructor call itself never signs or submits. The protected app delegation and user-exit interfaces have separate authentication and submission contracts, described below.
 
 | Tool | Builds | For |
 | --- | --- | --- |
 | `otto_prepare_swap` | A same-chain ERC-20 swap via LI.FI, as ready-to-sign steps | Your EOA or Safe on any supported EVM chain |
 | `otto_prepare_bridge` | A cross-chain native-USDC bridge over Circle CCTP (Ethereum, Polygon, Base, Arbitrum, Avalanche) | Your EOA or Safe |
 | `otto_prepare_polymarket_order` | A Polymarket CTF Exchange V2 limit order as typed data, tick and size validated against the live market | Your Polygon EOA |
-| `otto_prepare_perp_order` | A Hyperliquid perp limit order (optional take-profit / stop-loss), as the L1 action plus the exact EIP-712 recipe to sign | Your Hyperliquid account |
+| `otto_prepare_stock_buy` | A registry-bound tokenized-stock purchase with Base USDC | Your Base account |
+| `otto_prepare_yield_deposit` | A registry-bound vault deposit from Base USDC | Your Base account |
+| `otto_prepare_yield_withdraw` | A registry-bound vault-share withdrawal into USDC in the same account | Your Base account |
+
+**Hyperliquid retirement:** `otto_prepare_perp_order` is absent from public discovery and calls through old MCP definitions refuse with `HYPERLIQUID_RETIRED`. New orders, deposits and delegation are unavailable. Read-only market/account/history research and protected close, cancel, withdrawal, status and reconciliation remain. The retained unsigned SDK constructor accepts only explicit reduce-only recovery, and its order builder refuses any non-reduce-only leg. Existing balances and jobs are unknown until verified; no environment flag restores new Hyperliquid trading.
 
 On a server with a chain view (the hosted rail), a quoted swap route is also **simulated from the address that will sign it** before it is prepared: the quote's shape is asserted first, then the asserted call is run against the node with the plan's own balance and allowance overridden. A route that reverts is re-quoted with that exchange denied; a route that cannot be simulated — a token whose storage layout has not been proven on-chain, a node that ignores overrides — is **refused by name rather than prepared unproven**. Today the proven tokens are USDC on Base and the two Yield Copilot vault shares (`gtUSDCp`, `steakUSDC`).
 
@@ -106,11 +117,57 @@ To verify, sign and submit an envelope from the command line or from code, use t
 - `otto_x_recipes` — Otto X's X Layer recipe menu with each recipe's payment requirement.
 - `otto_delegation_fence_status` — whether the delegated-send fence is installed on this server (read-only).
 
-The other four `otto_delegation_*` / `otto_submit_under_delegation` tools are server-to-server (they need Otto's delegation header); an agent reaches that path through `otto-execute delegate`, documented on the execution-seam page.
+The other delegation tools are protected server-to-server interfaces. Otto's app authenticates the end-user session before calling them. New Model B trading-permission reservations are retired; an existing permission can still be checked or revoked, and an already minted reservation can still be confirmed. The `otto-execute delegate` command does not create a new permission against the retirement server or expose general hosted delegated submission. Do not request or distribute Otto's private server header.
+
+### App transfer recovery
+
+This source provides three protected transfer/recovery interfaces, including the existing read surface and two new tools. Their presence in source does not establish that the hosted revision has been deployed or activated.
+
+- `otto_delegation_operations` reads the authenticated user's saved operation history.
+- `otto_delegation_reconcile` checks known Base transaction hashes for one saved operation. It updates matching receipts without resubmitting a CDP request or running another plan step.
+- `otto_delegation_exit` prepares an exact Base USDC transfer for the user to sign with Coinbase. The service validates and saves those signed bytes before broadcasting. Its explicit `retry_same` action can send only the already-saved transaction; it cannot change the amount, recipient, nonce or signature.
+
+An unresolved operation blocks conflicting activity across devices using the shared service journal. A missing transaction reference stays unresolved until its outcome can be proved. Revoking an Otto permission does not withdraw assets. Operators must complete the versioned readiness and worker-drain procedure in `SETUP.md` before activation.
+
+### Sponsored account application entry — unreleased and inactive
+
+The local candidate exports `otto-intel-mcp/sponsored-account`: `sponsoredAccountAvailability()` reports readiness, and `createSponsoredAccountService()` provides prepare, gas review, explicit submit, read and reconcile methods for one same-chain USDC-to-ERC20 swap. Native-currency output is refused because this version verifies ERC20 transfer settlement. The committed activation list is empty, so the factory refuses before opening a journal. With protected delegation configured, the source registers `otto_sponsored_account`; the dApp provides the current-session `POST /api/delegation/sponsored` API. Sending and recovery remain unavailable while the activation list is empty. The authenticated app review loads an existing swap or native operation ID; it does not provide a complete operation-preparation flow or a wallet upgrade action.
+
+The planned same-address account transport covers Ethereum, Base, Arbitrum, Optimism and Polygon. It requires a separately approved Coinbase account upgrade, a reviewed sponsor policy and bounded gas budgets. It does not perform that wallet upgrade. Avalanche and BNB Chain are outside this Coinbase upgrade transport; the companion's EOA path uses user-funded gas there.
+
+The implementation binds the current owner session and permission, verifies the exact swap, saves one idempotent provider request in the existing operation journal, and checks the individual UserOperation event plus token settlement before reporting completion. A provider acknowledgement alone is insufficient. Stop and recovery remain separate: an unresolved request keeps its claim and cannot be replaced with a fresh request.
+
+Ordinary startup preserves coherent existing internal schema 2, 3 and 4 journals without DDL, marker changes or claim repair. A truly empty database initializes all storage as schema 4 with every rail unready; unsupported or inconsistent storage refuses without repair. An explicit existing-journal migration to schema 4 requires the separately approved old-worker drain and exact prior version/coverage. Sponsorship readiness is a separate operator action; it does not enable an activation or widen a wallet permission. Existing native-yield execution refuses upgraded, code-bearing EOAs, so account upgrade rollout requires a compatibility decision first.
+
+### Native protocol UserOperations — source candidate, inactive
+
+The local `otto-intel-mcp/yield-userop-account` entry and protected `otto_native_yield_userop` tool support availability, native scope review/confirmation, operation gas review, explicit submit, owned read/reconciliation and consent revocation. The application proxy is `/api/delegation/native-userop`. These actions require separately reviewed source activation, wallet authority and current consent; neither activation list contains an entry. The app can review an existing native operation ID, but sending stays unavailable without the separately reviewed activation and authority. No wallet-upgrade control is provided.
+
+This transport verifies the native protocol calls and their settlement inside the account UserOperation. A receipt or simulation alone is insufficient. Native and swap operations share the existing journal, user claim, sponsor reservations and gas circuit breaker. An unresolved submission keeps the original operation identity and claim. Native consent does not authorize swaps, and a native-only provider policy cannot advertise swap execution.
+
+Internal journal schema 5 is a separate, explicit offline migration after old workers are drained; ordinary startup never performs it. Schema 4 cannot admit the new record variant. Source publication, live migration, account upgrade and funded acceptance remain separate gates.
+
+### Guarded LP collection UserOperations — source candidate, inactive
+
+The `otto-intel-mcp/lp-userop-account` entry, protected `otto_lp_collect_userop` tool and `/api/delegation/lp-userop` application proxy provide availability, prepare, gas review, explicit submit, owned read and reconcile for one existing Uniswap V3 position on Base. The current app has no LP operation review panel. All source activation lists remain empty. A separate wallet upgrade, reviewed immutable guard and provider policy, explicit operation review and journal readiness are required.
+
+The reviewed batch contains exactly the position approval and guarded collection. The guard restores the position's approval to zero on success; an atomic revert restores its previous state. Completion requires the exact UserOperation, finalized receipt, attributed token and guard events, and canonical protocol accounting. Collection can include previously owed principal and fees: profit remains `UNKNOWN`, and no distributable-profit amount is inferred.
+
+LP, native and swap records share the same user claim, sponsor budget and gas circuit breaker. Ambiguous delivery retains the original request and claim. Recovery does not resubmit. Internal schema 6 requires a separate drained migration from schema 5 and an explicit LP readiness action. Source publication does not activate this rail.
+
+### Initial gas subsidy and account-paid pilot — inactive
+
+The three protected account tools also accept `reviewGas`, bound to the owned operation ID, current review commitment and requested payer preference. Refreshing an eligible, known-unsent review obtains current gas terms and requires fresh confirmation. Funding and **Check gas balance** never submit automatically; an unresolved provider request retains its original identity and claim.
+
+For a separately activated pilot, Otto may cover at most **USD 0.10 of initial transaction network gas**, shared by every call in one UserOperation. Provider API usage, subscriptions, paymaster markup and other non-gas charges are outside that allowance. A fresh provider policy and conservative sponsored estimate are refusal controls; live provider enforcement still requires verification before activation.
+
+Account-paid review is restricted to source-designated internal pilot accounts. The native-balance plus EntryPoint-deposit ceiling is an admission snapshot, not a persistent loss bound. The displayed estimate and separate 25% funding cushion are not a request-bound maximum fee; actual fees can differ. General real-user account-paid execution is outside this designated pilot and requires a separately reviewed activation scope. A payer change clears confirmation. Missing gas-price or sponsorship evidence cannot establish subsidy eligibility.
+
+The gas-review fields introduce no new journal schema version or automatic migration; supported versions still depend on the operation variant. Older strict readers can nevertheless reject the new records. Keep compatible recovery readers and resolve the worker-drain/rollback plan before activation; preserve every unresolved claim. Source publication, account funding and ordinary deployment do not activate the pilot.
 
 ## How paying works
 
-Calls are priced per tool ($0.001–$0.10) and paid in USDC on Base through x402. On the hosted server the first successful intelligence call from your network address (IP) is free; every call after that needs a payment:
+Calls are priced per tool ($0.001–$0.10) and paid in USDC on Base through x402. On the hosted server the first successful eligible intelligence call from your network address (IP) is free; every call after that needs a payment:
 
 1. Call the tool without `x_payment` → it returns `payment_required` (below) with the price and the exact requirement.
 2. Sign it with an x402 client from a wallet holding USDC on Base. With `@x402/core` + `@x402/evm` + `viem`:
@@ -135,7 +192,7 @@ const x_payment = encodePaymentSignatureHeader(payload); // base64 — the PAYME
 
 3. Retry the same tool with that string in `x_payment`. The paid result carries the settlement receipt in its metadata under `com.ottoai/payment-response` — keep it; it is the proof a later rating or refund claim is made against.
 
-If a route has no result for your input, it answers promptly and the free call is not consumed. If a paid delivery is interrupted, retry the same input with the same `x_payment`: the settled response is replayed without a second charge, or the attempt completes if it was never charged.
+If a route has no result for your input, it answers promptly and the free call is not consumed. If a paid delivery is interrupted, promptly retry the same input with the same `x_payment`; do not sign a new authorization merely to retry. The service may replay a saved result without another settlement while its delivery window permits. If it reports `settlement_unconfirmed` or `delivery_replay_expired`, retain the receipt and follow the response instructions or contact [support](https://docs.useotto.xyz/support-and-feedback/getting-help). Replay is not unlimited, and a receipt alone does not prove the expected data arrived.
 
 `payment_required` is the standard x402 v2 body (`accepts[0]` is the requirement to sign; `payment.requirement` is the same one, flattened for reading; `payment_required_header` is it base64-encoded for clients that consume the header form). Each requirement is valid for 300 seconds. If your MCP client has no x402 wallet of its own, the local server is the simplest route: it signs every payment from `X402_PRIVATE_KEY` automatically, with no free call.
 
@@ -195,7 +252,7 @@ An unpaid call after the free one returns `isError: true` with this payload (abb
 }
 ```
 
-Constructor arguments (addresses are `0x` + 40 hex; swap and bridge amounts are strings in atomic token units; Polymarket price/size and Hyperliquid size/price are plain decimal strings):
+Constructor arguments (addresses are `0x` + 40 hex; swap and bridge amounts are strings in atomic token units; Polymarket price/size are plain decimal strings):
 
 ```json
 {
@@ -214,13 +271,12 @@ Constructor arguments (addresses are `0x` + 40 hex; swap and bridge amounts are
 
 - `otto_prepare_bridge`: `accountProfile`, `fromChainId`, `toChainId`, `fromToken`, `toToken` (native USDC on each side), `fromAmount`, `slippage`, optional `destinationRecipient` (required for a Safe).
 - `otto_prepare_polymarket_order`: `accountProfile` (chainId 137), `tokenId` (the outcome token, not the condition id), `side` `BUY|SELL`, `price` (e.g. `"0.045"`, on the market's tick), `size` (shares).
-- `otto_prepare_perp_order`: `accountProfile` (chainId 1337), `asset` (e.g. `"BTC"`), `side`, `size`, `limitPrice`, optional `timeInForce` `Gtc|Ioc|Alo`, `reduceOnly`, `takeProfitPrice`, `stopLossPrice`, `tradingSigner`, `vaultAddress`.
 
 Every tool's full description and JSON schema comes back from `tools/list`.
 
 ## Using this package as a library
 
-Three import paths, for code that consumes what the constructors produce (there is no root import — use the subpaths):
+Use the package subpaths; there is no root import. Code that consumes constructor envelopes uses:
 
 - `otto-intel-mcp/execution` — the envelope schema and types, the digest and freshness assertions, the fee and delegation constants.
 - `otto-intel-mcp/adapter` — verify an envelope against your own intent and sign or submit it with an EOA.
@@ -233,6 +289,6 @@ Field-by-field documentation: https://docs.useotto.xyz/acp-swarm/execution-seam.
 - Docs: https://docs.useotto.xyz/acp-swarm/otto-intel-mcp · execution seam: https://docs.useotto.xyz/acp-swarm/execution-seam
 - The full Otto x402 catalog: https://x402.ottoai.services
 - Otto AI: https://useotto.xyz · X: [@useOttoAI](https://x.com/useOttoAI)
-- Changelog: 0.1.3 — swap-shaped constructors on a server with a chain view now SIMULATE the quoted route from the signing account before preparing it (a reverting exchange tool is re-quoted and denied; an unprovable route is refused by name — see the execution constructors section), and the library entries ship the fence-v2 policy lineage (`MODEL_B_POLICY_*_V2`, `MODEL_B_POLICY_DIGEST_BY_NAME`) that the `otto-execute` CLI needs to recognise the current fence; 0.1.2 — the hosted front door (`GET /`, `/health`) reports the live tool registry (21 tools, never a literal), the local server carries the settlement receipt like the hosted one, constructor descriptions state the freshness window, `serverInfo.version` = the package version; 0.1.1 — README rewritten for first-time users and agents, source maps removed from the package, publish gated by a privacy audit; 0.1.0 — first release (hosted + local server, execution constructors, library entries).
+- Changelog: 0.1.4 candidate — reviewed Optimism swap construction/verification, hybrid/native yield library entries, a fenced sponsored-account entry and shared journal schema v4. Ordinary startup preserves coherent existing journals; an explicit migration requires the separately approved old-worker drain. Package publication alone does not activate these paths. 0.1.3 — swap-shaped constructors on a server with a chain view now SIMULATE the quoted route from the signing account before preparing it (a reverting exchange tool is re-quoted and denied; an unprovable route is refused by name — see the execution constructors section), and the library entries ship the fence-v2 policy lineage (`MODEL_B_POLICY_*_V2`, `MODEL_B_POLICY_DIGEST_BY_NAME`) that the `otto-execute` CLI needs to recognise the current fence; 0.1.2 — the hosted front door (`GET /`, `/health`) reports the live tool registry (21 tools, never a literal), the local server carries the settlement receipt like the hosted one, constructor descriptions state the freshness window, `serverInfo.version` = the package version; 0.1.1 — README rewritten for first-time users and agents, source maps removed from the package, publish gated by a privacy audit; 0.1.0 — first release (hosted + local server, execution constructors, library entries).
 
 Running the hosted server yourself, or building from the monorepo: see `SETUP.md` in the repository.

package/dist/account-userop-policy-definition.d.ts

@@ -0,0 +1,14 @@
+/** Pure schema for a separately reviewed full native-plus-LP provider policy. */
+import { z } from 'zod';
+export declare const ACCOUNT_NATIVE_LP_USEROP_COMPILER: "legacy-v2-native-lp-collect-enduser-userop-v1";
+export declare const SPONSORED_LP_USEROP_POLICY_RELATION_SCHEMA: z.ZodObject<{
+    compiler: z.ZodLiteral<"legacy-v2-native-lp-collect-enduser-userop-v1">;
+    nativeCompiledPolicyDigest: z.ZodString;
+    nativeActivationCommitment: z.ZodString;
+    nativeRulesDigest: z.ZodString;
+    lpActivationCommitment: z.ZodString;
+    lpRulesDigest: z.ZodString;
+    compiledFullPolicyDigest: z.ZodString;
+    relationReviewEvidenceDigest: z.ZodString;
+}, z.core.$strict>;
+export type LpUserOpPolicyRelation = z.infer<typeof SPONSORED_LP_USEROP_POLICY_RELATION_SCHEMA>;

package/dist/account-userop-policy-definition.js

@@ -0,0 +1,12 @@
+/** Pure schema for a separately reviewed full native-plus-LP provider policy. */
+import { z } from 'zod';
+const digest = z.string().regex(/^[0-9a-f]{64}$/).refine(value => !/^0+$/.test(value));
+const commitment = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+export const ACCOUNT_NATIVE_LP_USEROP_COMPILER = 'legacy-v2-native-lp-collect-enduser-userop-v1';
+export const SPONSORED_LP_USEROP_POLICY_RELATION_SCHEMA = z.object({
+    compiler: z.literal(ACCOUNT_NATIVE_LP_USEROP_COMPILER),
+    nativeCompiledPolicyDigest: digest, nativeActivationCommitment: commitment, nativeRulesDigest: digest,
+    lpActivationCommitment: commitment, lpRulesDigest: digest, compiledFullPolicyDigest: digest,
+    relationReviewEvidenceDigest: digest,
+}).strict();
+//# sourceMappingURL=account-userop-policy-definition.js.map

package/dist/account-userop-policy-relation.d.ts

@@ -0,0 +1,371 @@
+import type { NativeYieldAccountActivation } from './native-yield-account-definition.js';
+import type { SponsoredActivation } from './execution-sponsored-definition.js';
+import { type LpUserOpActivation } from './lp-userop-definition.js';
+export { ACCOUNT_NATIVE_LP_USEROP_COMPILER, SPONSORED_LP_USEROP_POLICY_RELATION_SCHEMA, type LpUserOpPolicyRelation } from './account-userop-policy-definition.js';
+export declare class LpUserOpPolicyRefusal extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare function lpUserOpActivationCommitment(raw: LpUserOpActivation): `sha256:${string}`;
+/**
+ * Provider scope is per call: Base, zero native value, pinned NPM/guard, and only
+ * approve(guard, tokenId) or the guard's exact collect selector. The immutable
+ * guard enforces the caller/recipient, position, pair and atomic NFT cleanup.
+ * The host separately enforces exactly [approve, collect]. This provider rule
+ * cannot express batch cardinality/order; allowed subsets/repetitions remain a
+ * provider-authority residual, including a standalone approval to the guard.
+ * Tuple-parameter enforcement is not claimed. Provider acceptance and denial
+ * evidence remain an activation gate, independent of SDK schema parsing.
+ */
+export declare function compileLpCollectEndUserOperationRules(raw: LpUserOpActivation): {
+    action: "accept";
+    operation: "sendEndUserOperation";
+    criteria: ({
+        type: "evmNetwork";
+        networks: "base"[];
+        operator: "in";
+        ethValue?: undefined;
+        addresses?: undefined;
+        abi?: undefined;
+        conditions?: undefined;
+    } | {
+        type: "ethValue";
+        ethValue: string;
+        operator: "<=";
+        networks?: undefined;
+        addresses?: undefined;
+        abi?: undefined;
+        conditions?: undefined;
+    } | {
+        type: "evmAddress";
+        addresses: `0x${string}`[];
+        operator: "in";
+        networks?: undefined;
+        ethValue?: undefined;
+        abi?: undefined;
+        conditions?: undefined;
+    } | {
+        type: "evmData";
+        abi: ({
+            readonly name: "approve";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly type: "address";
+                readonly name: "to";
+            }, {
+                readonly type: "uint256";
+                readonly name: "tokenId";
+            }];
+            readonly outputs: readonly [];
+        } | {
+            readonly name: "collect";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly type: "tuple";
+                readonly components: readonly [{
+                    readonly type: "address";
+                    readonly name: "owner";
+                }, {
+                    readonly type: "address";
+                    readonly name: "pool";
+                }, {
+                    readonly type: "uint256";
+                    readonly name: "tokenId";
+                }, {
+                    readonly type: "int24";
+                    readonly name: "tickLower";
+                }, {
+                    readonly type: "int24";
+                    readonly name: "tickUpper";
+                }, {
+                    readonly type: "uint128";
+                    readonly name: "amount0Max";
+                }, {
+                    readonly type: "uint128";
+                    readonly name: "amount1Max";
+                }, {
+                    readonly type: "uint256";
+                    readonly name: "amount0Min";
+                }, {
+                    readonly type: "uint256";
+                    readonly name: "amount1Min";
+                }, {
+                    readonly type: "uint256";
+                    readonly name: "deadline";
+                }];
+                readonly name: "params";
+            }];
+            readonly outputs: readonly [{
+                readonly type: "uint256";
+                readonly name: "amount0";
+            }, {
+                readonly type: "uint256";
+                readonly name: "amount1";
+            }];
+        })[];
+        conditions: ({
+            function: string;
+            params: {
+                name: string;
+                operator: "in";
+                values: `0x${string}`[];
+            }[];
+        } | {
+            function: string;
+            params?: undefined;
+        })[];
+        networks?: undefined;
+        operator?: undefined;
+        ethValue?: undefined;
+        addresses?: undefined;
+    })[];
+}[];
+export declare function compileNativeLpCollectEndUserOperationPolicy(nativeActivation: NativeYieldAccountActivation, rawLpActivation: LpUserOpActivation): {
+    body: {
+        scope: "project";
+        description: "OTTO model b swap fence v3";
+        rules: (import("./execution-delegation-policy.js").DelegationPolicyRule | {
+            operation: "sendEndUserOperation";
+            action: "accept";
+            criteria: readonly import("./native-yield-account-policy.js").NativeYieldAccountPolicyCriterion[];
+        } | {
+            action: "accept";
+            operation: "sendEndUserOperation";
+            criteria: ({
+                type: "evmNetwork";
+                networks: "base"[];
+                operator: "in";
+                ethValue?: undefined;
+                addresses?: undefined;
+                abi?: undefined;
+                conditions?: undefined;
+            } | {
+                type: "ethValue";
+                ethValue: string;
+                operator: "<=";
+                networks?: undefined;
+                addresses?: undefined;
+                abi?: undefined;
+                conditions?: undefined;
+            } | {
+                type: "evmAddress";
+                addresses: `0x${string}`[];
+                operator: "in";
+                networks?: undefined;
+                ethValue?: undefined;
+                abi?: undefined;
+                conditions?: undefined;
+            } | {
+                type: "evmData";
+                abi: ({
+                    readonly name: "approve";
+                    readonly type: "function";
+                    readonly stateMutability: "nonpayable";
+                    readonly inputs: readonly [{
+                        readonly type: "address";
+                        readonly name: "to";
+                    }, {
+                        readonly type: "uint256";
+                        readonly name: "tokenId";
+                    }];
+                    readonly outputs: readonly [];
+                } | {
+                    readonly name: "collect";
+                    readonly type: "function";
+                    readonly stateMutability: "nonpayable";
+                    readonly inputs: readonly [{
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly type: "address";
+                            readonly name: "owner";
+                        }, {
+                            readonly type: "address";
+                            readonly name: "pool";
+                        }, {
+                            readonly type: "uint256";
+                            readonly name: "tokenId";
+                        }, {
+                            readonly type: "int24";
+                            readonly name: "tickLower";
+                        }, {
+                            readonly type: "int24";
+                            readonly name: "tickUpper";
+                        }, {
+                            readonly type: "uint128";
+                            readonly name: "amount0Max";
+                        }, {
+                            readonly type: "uint128";
+                            readonly name: "amount1Max";
+                        }, {
+                            readonly type: "uint256";
+                            readonly name: "amount0Min";
+                        }, {
+                            readonly type: "uint256";
+                            readonly name: "amount1Min";
+                        }, {
+                            readonly type: "uint256";
+                            readonly name: "deadline";
+                        }];
+                        readonly name: "params";
+                    }];
+                    readonly outputs: readonly [{
+                        readonly type: "uint256";
+                        readonly name: "amount0";
+                    }, {
+                        readonly type: "uint256";
+                        readonly name: "amount1";
+                    }];
+                })[];
+                conditions: ({
+                    function: string;
+                    params: {
+                        name: string;
+                        operator: "in";
+                        values: `0x${string}`[];
+                    }[];
+                } | {
+                    function: string;
+                    params?: undefined;
+                })[];
+                networks?: undefined;
+                operator?: undefined;
+                ethValue?: undefined;
+                addresses?: undefined;
+            })[];
+        })[];
+    };
+    compiler: "legacy-v2-native-lp-collect-enduser-userop-v1";
+    nativeCompiledPolicyDigest: string;
+    nativeActivationCommitment: `sha256:${string}`;
+    nativeRulesDigest: string;
+    lpActivationCommitment: `sha256:${string}`;
+    lpRulesDigest: string;
+    compiledFullPolicyDigest: string;
+};
+/** Preserve the existing native-only compiler proof; the new relation binds the augmented actual policy. */
+export declare function assertNativeLpCollectPolicyRelation(nativeActivation: NativeYieldAccountActivation, sponsorActivation: SponsoredActivation & {
+    readonly lpUserOpPolicyRelation?: unknown;
+}, lpActivation: LpUserOpActivation): {
+    body: {
+        scope: "project";
+        description: "OTTO model b swap fence v3";
+        rules: (import("./execution-delegation-policy.js").DelegationPolicyRule | {
+            operation: "sendEndUserOperation";
+            action: "accept";
+            criteria: readonly import("./native-yield-account-policy.js").NativeYieldAccountPolicyCriterion[];
+        } | {
+            action: "accept";
+            operation: "sendEndUserOperation";
+            criteria: ({
+                type: "evmNetwork";
+                networks: "base"[];
+                operator: "in";
+                ethValue?: undefined;
+                addresses?: undefined;
+                abi?: undefined;
+                conditions?: undefined;
+            } | {
+                type: "ethValue";
+                ethValue: string;
+                operator: "<=";
+                networks?: undefined;
+                addresses?: undefined;
+                abi?: undefined;
+                conditions?: undefined;
+            } | {
+                type: "evmAddress";
+                addresses: `0x${string}`[];
+                operator: "in";
+                networks?: undefined;
+                ethValue?: undefined;
+                abi?: undefined;
+                conditions?: undefined;
+            } | {
+                type: "evmData";
+                abi: ({
+                    readonly name: "approve";
+                    readonly type: "function";
+                    readonly stateMutability: "nonpayable";
+                    readonly inputs: readonly [{
+                        readonly type: "address";
+                        readonly name: "to";
+                    }, {
+                        readonly type: "uint256";
+                        readonly name: "tokenId";
+                    }];
+                    readonly outputs: readonly [];
+                } | {
+                    readonly name: "collect";
+                    readonly type: "function";
+                    readonly stateMutability: "nonpayable";
+                    readonly inputs: readonly [{
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly type: "address";
+                            readonly name: "owner";
+                        }, {
+                            readonly type: "address";
+                            readonly name: "pool";
+                        }, {
+                            readonly type: "uint256";
+                            readonly name: "tokenId";
+                        }, {
+                            readonly type: "int24";
+                            readonly name: "tickLower";
+                        }, {
+                            readonly type: "int24";
+                            readonly name: "tickUpper";
+                        }, {
+                            readonly type: "uint128";
+                            readonly name: "amount0Max";
+                        }, {
+                            readonly type: "uint128";
+                            readonly name: "amount1Max";
+                        }, {
+                            readonly type: "uint256";
+                            readonly name: "amount0Min";
+                        }, {
+                            readonly type: "uint256";
+                            readonly name: "amount1Min";
+                        }, {
+                            readonly type: "uint256";
+                            readonly name: "deadline";
+                        }];
+                        readonly name: "params";
+                    }];
+                    readonly outputs: readonly [{
+                        readonly type: "uint256";
+                        readonly name: "amount0";
+                    }, {
+                        readonly type: "uint256";
+                        readonly name: "amount1";
+                    }];
+                })[];
+                conditions: ({
+                    function: string;
+                    params: {
+                        name: string;
+                        operator: "in";
+                        values: `0x${string}`[];
+                    }[];
+                } | {
+                    function: string;
+                    params?: undefined;
+                })[];
+                networks?: undefined;
+                operator?: undefined;
+                ethValue?: undefined;
+                addresses?: undefined;
+            })[];
+        })[];
+    };
+    compiler: "legacy-v2-native-lp-collect-enduser-userop-v1";
+    nativeCompiledPolicyDigest: string;
+    nativeActivationCommitment: `sha256:${string}`;
+    nativeRulesDigest: string;
+    lpActivationCommitment: `sha256:${string}`;
+    lpRulesDigest: string;
+    compiledFullPolicyDigest: string;
+};