otto-intel-mcp 0.1.2 → 0.1.4

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

@@ -0,0 +1,87 @@
+/** Pure source-policy relation for native yield plus same-account guarded LP collection. */
+import { getAddress } from 'viem';
+import { z } from 'zod';
+import { freezeHybridValue, hybridYieldCommitment } from './hybrid-yield-markets.js';
+import { policyRulesDigest } from './execution-policy-compatibility.js';
+import { compileNativeYieldEndUserOperationPolicy } from './native-yield-userop-policy.js';
+import { LP_USEROP_ACTIVATION_SCHEMA } from './lp-userop-definition.js';
+import { LP_V3_BASE } from './vendor/lp-v3/lp-v3-contract.js';
+import { LP_V3_ATOMIC_NPM_ABI, LP_V3_COLLECT_GUARD_ABI } from './vendor/lp-v3/lp-v3-atomic-contract.js';
+const digest = z.string().regex(/^[0-9a-f]{64}$/).refine(value => !/^0+$/.test(value));
+import { ACCOUNT_NATIVE_LP_USEROP_COMPILER, SPONSORED_LP_USEROP_POLICY_RELATION_SCHEMA } from './account-userop-policy-definition.js';
+export { ACCOUNT_NATIVE_LP_USEROP_COMPILER, SPONSORED_LP_USEROP_POLICY_RELATION_SCHEMA } from './account-userop-policy-definition.js';
+export class LpUserOpPolicyRefusal extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'LpUserOpPolicyRefusal';
+    }
+}
+function ensure(value, code) { if (!value)
+    throw new LpUserOpPolicyRefusal(code); }
+export function lpUserOpActivationCommitment(raw) {
+    return hybridYieldCommitment(LP_USEROP_ACTIVATION_SCHEMA.parse(raw));
+}
+/**
+ * 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 function compileLpCollectEndUserOperationRules(raw) {
+    const activation = LP_USEROP_ACTIVATION_SCHEMA.parse(raw);
+    const guard = getAddress(activation.guardDeployment.address), manager = getAddress(LP_V3_BASE.manager);
+    const approvalAbi = LP_V3_ATOMIC_NPM_ABI.filter(item => item.type === 'function' && item.name === 'approve');
+    const collectionAbi = LP_V3_COLLECT_GUARD_ABI.filter(item => item.type === 'function' && item.name === 'collect');
+    ensure(approvalAbi.length === 1 && collectionAbi.length === 1 && guard !== manager, 'LP_USEROP_POLICY_ABI_UNAVAILABLE');
+    return freezeHybridValue([{
+            action: 'accept', operation: 'sendEndUserOperation',
+            criteria: [
+                { type: 'evmNetwork', networks: ['base'], operator: 'in' },
+                { type: 'ethValue', ethValue: '0', operator: '<=' },
+                { type: 'evmAddress', addresses: [manager, guard], operator: 'in' },
+                { type: 'evmData', abi: [...approvalAbi, ...collectionAbi], conditions: [
+                        { function: 'approve', params: [{ name: 'to', operator: 'in', values: [guard] }] },
+                        { function: 'collect' },
+                    ] },
+            ],
+        }]);
+}
+export function compileNativeLpCollectEndUserOperationPolicy(nativeActivation, rawLpActivation) {
+    const native = compileNativeYieldEndUserOperationPolicy(nativeActivation);
+    const lpActivation = LP_USEROP_ACTIVATION_SCHEMA.parse(rawLpActivation);
+    ensure(lpActivation.nativeActivationCommitment === native.nativeActivationCommitment, 'LP_USEROP_NATIVE_ACTIVATION_RELATION');
+    const lpRules = compileLpCollectEndUserOperationRules(lpActivation), rules = [...native.body.rules, ...lpRules];
+    ensure(lpRules.length === 1 && rules.length <= 10, 'LP_USEROP_POLICY_RULE_LIMIT');
+    return freezeHybridValue({
+        body: { scope: 'project', description: native.body.description, rules },
+        compiler: ACCOUNT_NATIVE_LP_USEROP_COMPILER,
+        nativeCompiledPolicyDigest: native.compiledFullPolicyDigest,
+        nativeActivationCommitment: native.nativeActivationCommitment, nativeRulesDigest: native.nativeRulesDigest,
+        lpActivationCommitment: lpUserOpActivationCommitment(lpActivation), lpRulesDigest: policyRulesDigest(lpRules),
+        compiledFullPolicyDigest: policyRulesDigest(rules),
+    });
+}
+/** Preserve the existing native-only compiler proof; the new relation binds the augmented actual policy. */
+export function assertNativeLpCollectPolicyRelation(nativeActivation, sponsorActivation, lpActivation) {
+    const base = compileNativeYieldEndUserOperationPolicy(nativeActivation);
+    const compiled = compileNativeLpCollectEndUserOperationPolicy(nativeActivation, lpActivation);
+    const relation = SPONSORED_LP_USEROP_POLICY_RELATION_SCHEMA.parse(sponsorActivation.lpUserOpPolicyRelation);
+    const native = sponsorActivation.nativeYieldUserOpPolicyRelation;
+    ensure(native && native.compiler === base.compiler &&
+        native.nativeActivationCommitment === base.nativeActivationCommitment &&
+        native.nativeRulesDigest === base.nativeRulesDigest && native.compiledFullPolicyDigest === base.compiledFullPolicyDigest &&
+        digest.safeParse(native.relationReviewEvidenceDigest).success, 'LP_USEROP_NATIVE_POLICY_RELATION');
+    const { relationReviewEvidenceDigest: _reviewEvidence, ...derived } = relation;
+    const { body: _body, ...expected } = compiled;
+    ensure(hybridYieldCommitment(derived) === hybridYieldCommitment(expected) &&
+        sponsorActivation.policyId === nativeActivation.policyId && sponsorActivation.policyName === nativeActivation.policyName &&
+        sponsorActivation.policyRulesDigest === compiled.compiledFullPolicyDigest, 'LP_USEROP_COMPOSITE_POLICY_RELATION');
+    return compiled;
+}
+//# sourceMappingURL=account-userop-policy-relation.js.map

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

@@ -27,6 +27,7 @@
 import { type Address, type Hex, type PublicClient } from 'viem';
 import { type SealedWaitOptions } from './chain.js';
 import type { SentStep } from './sent-step.js';
+import { AdapterRefusal } from './refusal.js';
 import { type SigningCapability, type VerifiedSwap } from './verify.js';
 export declare const CDP_CAPABILITIES: readonly SigningCapability[];
 export declare const CHAIN_ID: 8453;
@@ -40,6 +41,31 @@ export interface CdpEndUser {
     readonly userId: string;
     readonly address: Address;
 }
+export interface DelegatedSubmissionAttempt {
+    readonly index: number;
+    readonly kind: 'approve_reset' | 'approve' | 'call' | 'allowance_clear';
+    readonly userId: string;
+    readonly address: Address;
+    readonly transaction: Hex;
+    readonly network: typeof NETWORK;
+}
+export interface DelegatedSubmissionReceipt {
+    readonly transactionHash: Hex;
+    readonly status: 'success' | 'reverted';
+    readonly blockNumber: string;
+    readonly blockHash: Hex;
+    readonly gasUsed: string;
+}
+/** Durable observer used by the hosted delegated path. Its prepare call must commit before it resolves. */
+export interface DelegatedSubmissionJournal {
+    prepare(attempt: DelegatedSubmissionAttempt): Promise<{
+        readonly idempotencyKey: string;
+    }>;
+    notSubmitted(index: number, idempotencyKey: string): Promise<void>;
+    submitted(index: number, idempotencyKey: string, transactionHash: Hex): Promise<void>;
+    unknown(index: number, idempotencyKey: string): Promise<void>;
+    receipt(index: number, idempotencyKey: string, receipt: DelegatedSubmissionReceipt): Promise<void>;
+}
 /** The PUBLIC face of a rig: chain reads, delegation read-back, revocation. No submission surface. */
 export interface CdpRig {
     readonly pub: PublicClient;
@@ -57,24 +83,33 @@ export interface CdpRig {
 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>;
+    submit(user: CdpEndUser, unsignedTransaction: Hex, idempotencyKey?: string): 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;
+/**
+ * True once revocation was requested on this rig for THIS grant — the one expiring at `expiresAt`.
+ * A user with no live grant, or with a different one, is not marked.
+ */
+export declare function revocationRequested(rig: CdpRig, userId: string, expiresAt: 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';
+export type DelegatedHaltCause = 'policy_violation' | 'delegation_not_active' | 'artifact_no_longer_signable' | 'reverted'
+/** A later step's gas estimate reverted after an earlier step had landed; nothing more was broadcast. */
+ | 'would_revert'
+/** The node could not estimate a later step (timeout, rate limit, transport); nothing more was broadcast. */
+ | 'estimate_unavailable' | '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.
+ * A delegated plan halted; `cause` is the structured class above. `allowanceCleared` reports only
+ * whether the bounded cleanup's live, unpinned allowance read returned zero. It is diagnostic and is
+ * never sufficient to release a durable operation claim; finalized-canonical recovery owns that proof.
+ * 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;
@@ -103,19 +138,51 @@ export declare function openCdpRig(credentials: CdpDeveloperCredentials, rpcUrl?
  * 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>;
+/**
+ * A plan step whose gas estimate REVERTED. The node evaluates nothing of Coinbase's policy — the policy
+ * engine answers at submission, not at `eth_estimateGas` — so a reverting estimate is a transaction that
+ * would revert on chain, and broadcasting it anyway would spend the user's gas and buy nothing.
+ *
+ * 🔴 THIS IS WHAT THE STATIC 400,000 FALLBACK USED TO DO (2026-09-03, the first live delegated swap):
+ * the estimate reverted, the step went out at 400k, reverted on chain (234k gas burned), and only then
+ * did the halt path clear the allowance. 400k was also below every LI.FI swap's real need (~320–580k
+ * used, 1.1–1.4M quoted), so even a healthy route would have reverted under it. There is no fallback
+ * now: an estimate that reverts is a refusal, by name.
+ */
+export declare class DelegatedTransactionWouldRevertError extends AdapterRefusal {
+    readonly stepKind: string;
+    constructor(stepKind: string, detail: string);
+}
+/**
+ * A plan step the node could not estimate AT ALL — a timeout, a rate limit, a dropped connection. Nothing
+ * is proven about the transaction, so nothing is broadcast without an estimate; but it is NOT a revert:
+ * the caller may retry, and no route is blamed (gate r7, finding 2).
+ */
+export declare class DelegatedTransactionEstimateUnavailableError extends AdapterRefusal {
+    readonly stepKind: string;
+    constructor(stepKind: string, detail: string);
+}
+/** The bounded limit the halt path's `approve(spender, 0)` uses when the node cannot estimate it. */
+export declare const ALLOWANCE_CLEAR_STATIC_GAS = 80000n;
 export declare class CdpDelegatedSigner {
     #private;
     readonly capabilities: readonly SigningCapability[];
     readonly chainId: 8453;
     constructor(rig: CdpRig, user: CdpEndUser, options?: {
         readonly sealedWait?: SealedWaitOptions;
+        readonly beforeEachStep?: () => Promise<void>;
+        readonly afterBuild?: () => Promise<void>;
+        readonly beforeSubmit?: () => void;
+        readonly grantExpiresAt?: string;
+        readonly submissionJournal?: DelegatedSubmissionJournal;
     });
     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
+     * re-checked before every step — together with the caller's async `beforeEachStep`, which re-reads the
+     * GRANT and its recorded per-swap cap — 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.