otto-execute 0.1.0

package/dist/vendor/otto-intel-mcp/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/vendor/otto-intel-mcp/adapter/chain.d.ts

@@ -0,0 +1,36 @@
+/**
+ * chain.ts — the one chain-state rule both signers follow on Base.
+ *
+ * With Flashblocks, a transaction receipt can arrive from a PRECONFIRMATION while `latest` — the last
+ * SEALED block, the state every default read and gas estimate runs against — still predates it, and a
+ * preconfirmation is not final: Base defines a Flashblock reorg as a preconfirmed transaction OMITTED
+ * from the sealed block. Observed live on 2026-08-28: the approve was preconfirmed, the swap call was
+ * estimated against `latest`, and the router's `transferFrom` reverted `TRANSFER_FROM_FAILED` on an
+ * allowance that was already granted. Rule: a transaction counts as mined ONLY once its receipt is
+ * refetched by hash and the sealed canonical block at that height carries the receipt's block hash.
+ * Until then the signer touches no state (no next estimate, no allowance read-back); if that never
+ * happens within the bound, the signer fails closed. This is the conservative mechanism — it is also
+ * exactly what a user copying this flow in a wallet observes.
+ */
+import type { Hex, PublicClient, TransactionReceipt } from 'viem';
+export interface SealedWaitOptions {
+    /** Delay between polls (default 250 ms). */
+    readonly pollMs?: number;
+    /** Give up after this many polls (default 240 → 60 s at the default cadence). */
+    readonly maxPolls?: number;
+}
+export type SealedClient = Pick<PublicClient, 'getBlockNumber' | 'getTransactionReceipt' | 'getBlock'>;
+/** The wait gave up: no receipt in a sealed canonical block within the bound. A CLASS, so callers classify structurally. */
+export declare class SealedReceiptTimeoutError extends Error {
+    readonly hash: Hex;
+    readonly polls: number;
+    constructor(hash: Hex, polls: number);
+}
+/**
+ * Resolve with the receipt of `hash` once it is SEALED and CANONICAL: refetched by hash, its block
+ * number ≤ the sealed head, and the sealed block at that number has the receipt's `blockHash`. A
+ * preconfirmed receipt that was omitted from the sealed block (Flashblock reorg) is never returned —
+ * the wait continues until the transaction is re-included in a sealed block, or throws after
+ * `maxPolls` so the caller fails closed instead of treating the transaction as mined.
+ */
+export declare function waitForSealedReceipt(pub: SealedClient, hash: Hex, options?: SealedWaitOptions): Promise<TransactionReceipt>;

package/dist/vendor/otto-intel-mcp/adapter/chain.js

@@ -0,0 +1,65 @@
+/**
+ * chain.ts — the one chain-state rule both signers follow on Base.
+ *
+ * With Flashblocks, a transaction receipt can arrive from a PRECONFIRMATION while `latest` — the last
+ * SEALED block, the state every default read and gas estimate runs against — still predates it, and a
+ * preconfirmation is not final: Base defines a Flashblock reorg as a preconfirmed transaction OMITTED
+ * from the sealed block. Observed live on 2026-08-28: the approve was preconfirmed, the swap call was
+ * estimated against `latest`, and the router's `transferFrom` reverted `TRANSFER_FROM_FAILED` on an
+ * allowance that was already granted. Rule: a transaction counts as mined ONLY once its receipt is
+ * refetched by hash and the sealed canonical block at that height carries the receipt's block hash.
+ * Until then the signer touches no state (no next estimate, no allowance read-back); if that never
+ * happens within the bound, the signer fails closed. This is the conservative mechanism — it is also
+ * exactly what a user copying this flow in a wallet observes.
+ */
+/** The wait gave up: no receipt in a sealed canonical block within the bound. A CLASS, so callers classify structurally. */
+export class SealedReceiptTimeoutError extends Error {
+    hash;
+    polls;
+    constructor(hash, polls) {
+        super(`transaction ${hash} has no receipt in a sealed canonical block after ${polls} polls; refusing to treat it as mined`);
+        this.hash = hash;
+        this.polls = polls;
+        this.name = 'SealedReceiptTimeoutError';
+    }
+}
+/** STRUCTURAL: viem's own class name for "no receipt yet". Message text is never consulted — it must not select a class. */
+function isReceiptNotFound(error) {
+    return error?.name === 'TransactionReceiptNotFoundError';
+}
+/**
+ * Resolve with the receipt of `hash` once it is SEALED and CANONICAL: refetched by hash, its block
+ * number ≤ the sealed head, and the sealed block at that number has the receipt's `blockHash`. A
+ * preconfirmed receipt that was omitted from the sealed block (Flashblock reorg) is never returned —
+ * the wait continues until the transaction is re-included in a sealed block, or throws after
+ * `maxPolls` so the caller fails closed instead of treating the transaction as mined.
+ */
+export async function waitForSealedReceipt(pub, hash, options = {}) {
+    const pollMs = options.pollMs ?? 250;
+    const maxPolls = options.maxPolls ?? 240;
+    for (let poll = 0;; poll++) {
+        let receipt;
+        try {
+            receipt = await pub.getTransactionReceipt({ hash });
+        }
+        catch (error) {
+            if (!isReceiptNotFound(error))
+                throw error;
+        }
+        if (receipt) {
+            // viem caches getBlockNumber for the client's cacheTime by default — a cached head would defeat the wait.
+            const head = await pub.getBlockNumber({ cacheTime: 0 });
+            if (head >= receipt.blockNumber) {
+                const sealed = await pub.getBlock({ blockNumber: receipt.blockNumber });
+                if (sealed.hash === receipt.blockHash)
+                    return receipt;
+                // The block this receipt claims is not the sealed block at that height: the preconfirmation did
+                // not survive sealing. Keep polling — the transaction may be re-included in a later block.
+            }
+        }
+        if (poll + 1 >= maxPolls)
+            throw new SealedReceiptTimeoutError(hash, maxPolls);
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+}
+//# sourceMappingURL=chain.js.map

package/dist/vendor/otto-intel-mcp/adapter/erc20.d.ts

@@ -0,0 +1,39 @@
+/**
+ * erc20.ts — the two ERC-20 calls the signers make on their OWN behalf: the bounded `approve(spender, 0)`
+ * that clears a halted plan's allowance, and the `allowance` read-back that turns "the clear was
+ * mined" into "the allowance IS zero" — a receipt status is a claim about a transaction, the read-back
+ * is the fact about the token.
+ */
+import { type Address, type PublicClient } from 'viem';
+export declare const ERC20_APPROVE_ABI: readonly [{
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+export declare const ERC20_ALLOWANCE_ABI: readonly [{
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+/** The live allowance `owner` has granted `spender` on `token`. Throws if the read itself fails. */
+export declare function readAllowance(pub: PublicClient, token: Address, owner: Address, spender: Address): Promise<bigint>;

package/dist/vendor/otto-intel-mcp/adapter/erc20.js

@@ -0,0 +1,17 @@
+/**
+ * erc20.ts — the two ERC-20 calls the signers make on their OWN behalf: the bounded `approve(spender, 0)`
+ * that clears a halted plan's allowance, and the `allowance` read-back that turns "the clear was
+ * mined" into "the allowance IS zero" — a receipt status is a claim about a transaction, the read-back
+ * is the fact about the token.
+ */
+import { parseAbi } from 'viem';
+export const ERC20_APPROVE_ABI = parseAbi(['function approve(address spender, uint256 amount) returns (bool)']);
+export const ERC20_ALLOWANCE_ABI = parseAbi(['function allowance(address owner, address spender) view returns (uint256)']);
+/** The live allowance `owner` has granted `spender` on `token`. Throws if the read itself fails. */
+export async function readAllowance(pub, token, owner, spender) {
+    const value = await pub.readContract({ address: token, abi: ERC20_ALLOWANCE_ABI, functionName: 'allowance', args: [owner, spender] });
+    if (typeof value !== 'bigint')
+        throw new Error('allowance read-back did not return a uint256');
+    return value;
+}
+//# sourceMappingURL=erc20.js.map

package/dist/vendor/otto-intel-mcp/adapter/lifi-decode.d.ts

@@ -0,0 +1,52 @@
+/**
+ * lifi-decode.ts — the adapter's OWN decoder for what it is about to sign.
+ *
+ * Re-specified (not imported) from the reviewed layouts in `src/lib/otto-wallet/lifi-swap-action.ts`
+ * (GenericSwapV3 ERC20→ERC20: receiver@96 / minAmount@128, `LibSwap.SwapData` tuple) and the
+ * FeeCollector `collectTokenFees(token, (recipient, amount)[])` body. Spec §11 fences the dApp decoder
+ * as a live owner-op importer that must not move; spec §1 keeps the constructor's own assertions on
+ * the constructor's side. This file is the user-side view: if the two ever disagree, the artifact is
+ * refused, which is the correct outcome for a disagreement about calldata that moves money.
+ *
+ * Decoding runs on the ARG REGION with `decodeAbiParameters` after a separate selector check, so a
+ * selector/ABI mismatch cannot mask a correct-looking parameter decode. Every decode is re-encoded
+ * and compared to the input: trailing bytes or non-canonical encodings are refused, never ignored.
+ */
+import { type Address, type Hex } from 'viem';
+/** swapTokensSingleV3ERC20ToERC20 / swapTokensMultipleV3ERC20ToERC20 — the only selectors a swap plan may call. */
+export declare const GENERIC_SWAP_SELECTORS: Readonly<{
+    single: Hex;
+    multiple: Hex;
+}>;
+/** FeeCollector.collectTokenFees — the only calldata a fee-forwarding leg may carry. */
+export declare const COLLECT_TOKEN_FEES_SELECTOR: Hex;
+export interface SwapLeg {
+    readonly callTo: Address;
+    readonly approveTo: Address;
+    readonly sendingAssetId: Address;
+    readonly receivingAssetId: Address;
+    readonly fromAmount: bigint;
+    readonly callData: Hex;
+    readonly requiresDeposit: boolean;
+}
+export interface DecodedGenericSwap {
+    readonly selector: Hex;
+    readonly transactionId: Hex;
+    readonly integrator: string;
+    readonly referrer: string;
+    readonly receiver: Address;
+    readonly minAmount: bigint;
+    readonly legs: readonly SwapLeg[];
+}
+export interface FeeDistribution {
+    readonly recipient: Address;
+    readonly amount: bigint;
+}
+export interface DecodedCollectTokenFees {
+    readonly token: Address;
+    readonly distributions: readonly FeeDistribution[];
+}
+export declare function decodeGenericSwap(data: Hex): DecodedGenericSwap;
+export declare function decodeCollectTokenFees(callData: Hex): DecodedCollectTokenFees;
+export declare function encodeGenericSwap(swap: DecodedGenericSwap): Hex;
+export declare function encodeCollectTokenFees(fees: DecodedCollectTokenFees): Hex;