@forum-labs/payfetch 1.0.0

package/dist/src/mcp/tools.js

@@ -0,0 +1,321 @@
+import { join } from "node:path";
+import { USDC_DECIMALS } from "../core/constants.js";
+export const TOOL_NAMES = {
+    PAID_FETCH: "paid_fetch",
+    PAYMENT_QUOTE: "payment_quote",
+    SPEND_STATUS: "spend_status",
+    LIST_RECEIPTS: "list_receipts",
+    APPROVE_PENDING: "approve_pending",
+};
+export const TOOL_DESCRIPTIONS = {
+    paid_fetch: "Fetch a URL, automatically paying if it requires payment (HTTP 402, x402 protocol) — within the operator's spending policy. Free URLs are fetched normally at no cost. Use payment_quote first if you only want to know the price. Payments above the operator's approval threshold will ask the human for confirmation.",
+    payment_quote: "Check what a paid URL costs and whether the current spending policy would allow paying it, WITHOUT paying. Returns the price, payment terms, trust-check results, and the policy decision.",
+    spend_status: "Show today's agent spending: totals, remaining budgets overall and per host, active holds, and recent payments.",
+    list_receipts: "Query the local payment receipt ledger (audit trail). Filter by time, host, or outcome.",
+    approve_pending: "List or resolve payments waiting for human approval (queue mode). Approving grants a one-time re-run permission for that exact payment.",
+};
+const LIST_RECEIPTS_DEFAULT_LIMIT = 50;
+const LIST_RECEIPTS_MAX_LIMIT = 200;
+const HTTP_METHOD_ENUM = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"];
+const RESPONSE_MODE_ENUM = ["inline", "file"];
+const CHAIN_ENUM = ["solana", "base", "ethereum"];
+export const PAID_FETCH_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        url: { type: "string", format: "uri" },
+        method: { enum: [...HTTP_METHOD_ENUM], default: "GET" },
+        headers: { type: "object", additionalProperties: { type: "string" } },
+        body: { type: "string" },
+        maxAmountUsd: { type: "number", minimum: 0 },
+        dryRun: { type: "boolean", default: false },
+        responseMode: { enum: [...RESPONSE_MODE_ENUM], default: "inline" },
+        tokenAddress: { type: "string" },
+        chain: { enum: [...CHAIN_ENUM] },
+    },
+    required: ["url"],
+};
+export const PAYMENT_QUOTE_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        url: { type: "string", format: "uri" },
+        method: { enum: [...HTTP_METHOD_ENUM], default: "GET" },
+        headers: { type: "object", additionalProperties: { type: "string" } },
+        body: { type: "string" },
+        tokenAddress: { type: "string" },
+        chain: { enum: [...CHAIN_ENUM] },
+    },
+    required: ["url"],
+};
+export const SPEND_STATUS_INPUT_SCHEMA = {
+    type: "object",
+    properties: {},
+    additionalProperties: false,
+};
+export const LIST_RECEIPTS_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        sinceTs: { type: "number" },
+        host: { type: "string" },
+        outcome: { type: "string" },
+        limit: {
+            type: "number",
+            default: LIST_RECEIPTS_DEFAULT_LIMIT,
+            minimum: 1,
+            maximum: LIST_RECEIPTS_MAX_LIMIT,
+        },
+    },
+};
+export const APPROVE_PENDING_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        action: { enum: ["list", "approve", "deny"] },
+        approvalId: { type: "string" },
+    },
+    required: ["action"],
+};
+export const PAYFETCH_TOOLS = [
+    {
+        name: TOOL_NAMES.PAID_FETCH,
+        description: TOOL_DESCRIPTIONS.paid_fetch,
+        inputSchema: PAID_FETCH_INPUT_SCHEMA,
+    },
+    {
+        name: TOOL_NAMES.PAYMENT_QUOTE,
+        description: TOOL_DESCRIPTIONS.payment_quote,
+        inputSchema: PAYMENT_QUOTE_INPUT_SCHEMA,
+    },
+    {
+        name: TOOL_NAMES.SPEND_STATUS,
+        description: TOOL_DESCRIPTIONS.spend_status,
+        inputSchema: SPEND_STATUS_INPUT_SCHEMA,
+    },
+    {
+        name: TOOL_NAMES.LIST_RECEIPTS,
+        description: TOOL_DESCRIPTIONS.list_receipts,
+        inputSchema: LIST_RECEIPTS_INPUT_SCHEMA,
+    },
+    {
+        name: TOOL_NAMES.APPROVE_PENDING,
+        description: TOOL_DESCRIPTIONS.approve_pending,
+        inputSchema: APPROVE_PENDING_INPUT_SCHEMA,
+    },
+];
+export function policyLockNotice(dataDir) {
+    return `Spending limits and lists are set by the operator in ${dataDir}/config.json — they cannot be changed from this session.`;
+}
+export class UnknownToolError extends Error {
+    toolName;
+    constructor(toolName) {
+        super(`unknown tool: ${toolName}`);
+        this.toolName = toolName;
+        this.name = "UnknownToolError";
+    }
+}
+export class ToolInputError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+export async function dispatchTool(ctx, name, args) {
+    switch (name) {
+        case TOOL_NAMES.PAID_FETCH:
+            return handlePaidFetch(ctx, args);
+        case TOOL_NAMES.PAYMENT_QUOTE:
+            return handlePaymentQuote(ctx, args);
+        case TOOL_NAMES.SPEND_STATUS:
+            return ctx.pf.status();
+        case TOOL_NAMES.LIST_RECEIPTS:
+            return handleListReceipts(ctx, args);
+        case TOOL_NAMES.APPROVE_PENDING:
+            return handleApprovePending(ctx, args);
+        default:
+            throw new UnknownToolError(name);
+    }
+}
+async function handlePaidFetch(ctx, args) {
+    const url = requireString(args, "url");
+    const init = buildRequestInit(args);
+    const opts = {};
+    if (typeof args.maxAmountUsd === "number")
+        opts.maxAmountUsd = args.maxAmountUsd;
+    if (typeof args.dryRun === "boolean")
+        opts.dryRun = args.dryRun;
+    const responseMode = args.responseMode === "file" ? "file" : "inline";
+    opts.responseMode = responseMode;
+    if (typeof args.tokenAddress === "string")
+        opts.tokenAddress = args.tokenAddress;
+    if (typeof args.chain === "string")
+        opts.chain = args.chain;
+    const { response, receipt } = await ctx.pf.fetch(url, init, opts);
+    return mapPaidFetchResult(ctx.dataDir, receipt, response, responseMode);
+}
+async function mapPaidFetchResult(dataDir, receipt, response, responseMode) {
+    const base = {
+        receiptId: receipt.receiptId,
+        outcome: receipt.outcome,
+        status: receipt.http?.status ?? null,
+        contentType: receipt.http?.contentType ?? null,
+        bodyBytes: receipt.http?.bodyBytes ?? null,
+        truncated: receipt.http?.truncated ?? false,
+        payment: receipt.payment
+            ? {
+                outcome: receipt.outcome,
+                amountUsd: receipt.payment.settledAmountUsd ?? receipt.quote?.amountUsd ?? null,
+                txRef: receipt.payment.txRef,
+            }
+            : null,
+        warnings: buildWarnings(receipt),
+    };
+    if (receipt.outcome === "guard_blocked" && receipt.guardBlockReason) {
+        base.guardBlockReason = receipt.guardBlockReason;
+        base.guardBlockGuidance = guardBlockGuidance(receipt.guardBlockReason);
+    }
+    if (response !== null) {
+        if (responseMode === "file") {
+            return { ...base, bodyPath: join(dataDir, "downloads", receipt.receiptId) };
+        }
+        return { ...base, body: await response.text() };
+    }
+    if (receipt.outcome === "dry_run") {
+        return {
+            ...base,
+            denyCode: receipt.denyCode,
+            quote: receipt.quote,
+            remainingBudgets: receipt.budgets,
+        };
+    }
+    const denied = {
+        ...base,
+        denyCode: receipt.denyCode,
+        quote: receipt.quote,
+        remainingBudgets: receipt.budgets,
+        policyNotice: policyLockNotice(dataDir),
+    };
+    if (receipt.outcome === "approval_queued") {
+        denied.approvalId = receipt.receiptId;
+        denied.approvalInstructions =
+            "A human must approve this via the approve_pending tool (queue mode) before it can be re-run.";
+    }
+    if (receipt.outcome === "approval_denied" &&
+        (receipt.notes.includes("elicit_unsupported") || receipt.notes.includes("elicit_cancelled"))) {
+        denied.approvalGuidance = elicitBlockedGuidance(dataDir);
+    }
+    return denied;
+}
+function elicitBlockedGuidance(dataDir) {
+    return ("This payment is above the approval threshold, and the connected MCP client " +
+        "cannot prompt a human to approve it (it does not support elicitation, or it " +
+        "dismissed the prompt). This is NOT a denial by a human — it is blocked because " +
+        "there is no in-session approval channel. To allow payments like this WITHOUT a " +
+        `human dialog, the operator can edit ${dataDir}/config.json to (a) raise ` +
+        "approval.thresholdUsd, (b) set approval.preApprovedUpToUsd to a ceiling, or " +
+        "(c) add this host to approval.preApprovedHosts. Spending caps still apply, and " +
+        "these limits cannot be changed from this session.");
+}
+function guardBlockGuidance(reason) {
+    switch (reason) {
+        case "danger":
+            return "A trust/safety guard flagged this host or token as dangerous. This is a verdict, not a transient error — do NOT retry; use a different resource.";
+        case "degraded":
+            return "The safety screen was DEGRADED (incomplete danger data) so the enforce guard failed closed. A warm re-screen may clear it — retrying shortly may succeed.";
+        case "timeout":
+            return "The guard timed out on a cold screen. A warm screen is faster — retrying shortly may succeed.";
+        case "unavailable":
+            return "The guard was unavailable (upstream down, unpaid, or malformed). Retrying later may succeed; an operator can also adjust guards.*.onUnavailable.";
+    }
+}
+async function handlePaymentQuote(ctx, args) {
+    const url = requireString(args, "url");
+    const init = buildRequestInit(args);
+    const opts = { dryRun: true };
+    if (typeof args.tokenAddress === "string")
+        opts.tokenAddress = args.tokenAddress;
+    if (typeof args.chain === "string")
+        opts.chain = args.chain;
+    const { receipt } = await ctx.pf.fetch(url, init, opts);
+    return {
+        terms: receipt.quote ? [receipt.quote] : [],
+        selectedQuote: receipt.quote,
+        rejectedQuotes: receipt.rejectedQuotes,
+        decision: {
+            outcome: receipt.outcome,
+            denyCode: receipt.denyCode,
+            decision: receipt.outcome === "dry_run"
+                ? "would_pay"
+                : receipt.outcome === "free"
+                    ? "free"
+                    : "would_deny",
+            ...(receipt.guardBlockReason ? { guardBlockReason: receipt.guardBlockReason } : {}),
+        },
+        guards: receipt.guards,
+        remainingBudgets: receipt.budgets,
+        receiptId: receipt.receiptId,
+        warnings: buildWarnings(receipt),
+    };
+}
+async function handleListReceipts(ctx, args) {
+    const q = {};
+    if (typeof args.sinceTs === "number")
+        q.sinceTs = args.sinceTs;
+    if (typeof args.host === "string")
+        q.host = args.host;
+    if (typeof args.outcome === "string")
+        q.outcome = args.outcome;
+    if (typeof args.limit === "number")
+        q.limit = args.limit;
+    const receipts = await ctx.pf.receipts(q);
+    return { receipts, count: receipts.length };
+}
+function handleApprovePending(ctx, args) {
+    const action = args.action;
+    if (action === "list") {
+        return { approvals: ctx.pf.engine.listApprovals() };
+    }
+    if (action === "approve" || action === "deny") {
+        const approvalId = args.approvalId;
+        if (typeof approvalId !== "string" || approvalId.length === 0) {
+            throw new ToolInputError(`approvalId is required for action "${action}"`);
+        }
+        const res = ctx.pf.engine.resolveApproval(approvalId, action === "approve");
+        if (!res.ok) {
+            return { ok: false, error: res.error, action, approvalId };
+        }
+        return { ok: true, action, approvalId };
+    }
+    throw new ToolInputError(`unknown action "${String(action)}" — expected "list", "approve", or "deny"`);
+}
+function requireString(args, key) {
+    const v = args[key];
+    if (typeof v !== "string" || v.length === 0) {
+        throw new ToolInputError(`"${key}" is required and must be a non-empty string`);
+    }
+    return v;
+}
+function buildRequestInit(args) {
+    const init = {};
+    if (typeof args.method === "string")
+        init.method = args.method;
+    if (isStringRecord(args.headers))
+        init.headers = args.headers;
+    if (typeof args.body === "string")
+        init.body = args.body;
+    return init;
+}
+function isStringRecord(v) {
+    if (v === null || typeof v !== "object" || Array.isArray(v))
+        return false;
+    return Object.values(v).every((x) => typeof x === "string");
+}
+function buildWarnings(receipt) {
+    const out = [];
+    for (const g of receipt.guards) {
+        if (g.verdict === "warn" || g.verdict === "block" || g.verdict === "unavailable") {
+            out.push(`guard ${g.id}: ${g.verdict}`);
+        }
+    }
+    for (const n of receipt.notes)
+        out.push(n);
+    return out;
+}
+export const USD_DISPLAY_DECIMALS = USDC_DECIMALS;

package/dist/src/payer/mpp.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedChallenge, PayfetchDeps, PaymentPayer, PaymentProof, PaymentQuote, WalletSigner } from "./types.js";
+export declare class MppPayer implements PaymentPayer {
+    readonly rail: "mpp";
+    detects(_challenge: ParsedChallenge): boolean;
+    quotes(_challenge: ParsedChallenge): PaymentQuote[];
+    buildPayment(_quote: PaymentQuote, _signer: WalletSigner, _deps: PayfetchDeps): Promise<PaymentProof>;
+}

package/dist/src/payer/mpp.js

@@ -0,0 +1,13 @@
+import { UnsupportedRailError } from "./types.js";
+export class MppPayer {
+    rail = "mpp";
+    detects(_challenge) {
+        return false;
+    }
+    quotes(_challenge) {
+        throw new UnsupportedRailError("mpp", "quotes");
+    }
+    buildPayment(_quote, _signer, _deps) {
+        throw new UnsupportedRailError("mpp", "buildPayment");
+    }
+}

package/dist/src/payer/parse402.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedChallenge, X402Terms } from "./types.js";
+export declare function parseAcceptsEntry(raw: unknown): X402Terms | null;
+export declare function parseAccepts(rawAccepts: unknown): X402Terms[] | null;
+export declare function hashTerms(terms: readonly X402Terms[]): string;
+export declare function parseChallenge(rawBody: unknown): ParsedChallenge;
+export declare function parse402Challenge(rawBody: unknown, paymentRequiredHeader: string | null): ParsedChallenge;

package/dist/src/payer/parse402.js

@@ -0,0 +1,169 @@
+import { createHash } from "node:crypto";
+import { safeBase64Decode } from "@x402/core/utils";
+import { canonicalNetwork, deriveAmountUsd } from "../core/constants.js";
+function asRecord(v) {
+    return v != null && typeof v === "object" && !Array.isArray(v)
+        ? v
+        : null;
+}
+function asString(v) {
+    return typeof v === "string" ? v : null;
+}
+function asAtomicString(v) {
+    if (typeof v === "string" && v.trim().length > 0)
+        return v;
+    if (typeof v === "number" && Number.isFinite(v))
+        return String(v);
+    return null;
+}
+function asFiniteNumber(v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function sha256hex(input) {
+    return createHash("sha256").update(input).digest("hex");
+}
+export function parseAcceptsEntry(raw) {
+    const r = asRecord(raw);
+    if (!r)
+        return null;
+    const scheme = asString(r.scheme);
+    const networkRaw = asString(r.network);
+    const payToRaw = asString(r.payTo);
+    const amountAtomic = asAtomicString(r.maxAmountRequired ?? r.amount);
+    if (!scheme || !networkRaw || !payToRaw || amountAtomic == null)
+        return null;
+    const network = canonicalNetwork(networkRaw) ?? networkRaw;
+    const asset = asString(r.asset);
+    const payTo = payToRaw.toLowerCase();
+    const maxTimeoutSeconds = asFiniteNumber(r.maxTimeoutSeconds);
+    const mimeType = asString(r.mimeType);
+    const resource = asString(r.resource);
+    const outputSchema = asRecord(r.outputSchema);
+    const hasOutputSchema = outputSchema != null;
+    const outputSchemaSha256 = hasOutputSchema ? sha256hex(stableStringify(outputSchema)) : null;
+    const amountUsd = deriveAmountUsd(amountAtomic, asset);
+    return {
+        scheme,
+        network,
+        asset,
+        amountAtomic,
+        amountUsd,
+        payTo,
+        maxTimeoutSeconds,
+        mimeType,
+        hasOutputSchema,
+        outputSchemaSha256,
+        networkAsDeclared: networkRaw,
+        resource,
+        rawAccepts: raw,
+    };
+}
+export function parseAccepts(rawAccepts) {
+    if (!Array.isArray(rawAccepts))
+        return null;
+    const out = [];
+    for (const entry of rawAccepts) {
+        const t = parseAcceptsEntry(entry);
+        if (t)
+            out.push(t);
+    }
+    return out.length > 0 ? out : null;
+}
+export function hashTerms(terms) {
+    const rows = terms.map((t) => JSON.stringify([
+        t.scheme,
+        t.network,
+        t.asset,
+        t.amountAtomic,
+        t.payTo,
+        t.maxTimeoutSeconds,
+        t.mimeType,
+        t.outputSchemaSha256,
+    ]));
+    rows.sort();
+    return sha256hex(rows.join("\n")).slice(0, 16);
+}
+const MALFORMED = Object.freeze({
+    rail: null,
+    x402Version: null,
+    terms: [],
+    termsHash: null,
+    malformed: true,
+});
+export function parseChallenge(rawBody) {
+    const root = asRecord(toJson(rawBody));
+    if (!root)
+        return { ...MALFORMED };
+    const x402Version = asFiniteNumber(root.x402Version);
+    const acceptsPresent = Array.isArray(root.accepts);
+    const rail = x402Version !== null && acceptsPresent ? "x402" : null;
+    const terms = parseAccepts(root.accepts);
+    if (terms === null) {
+        return { rail, x402Version, terms: [], termsHash: null, malformed: true };
+    }
+    const resourceUrl = asString(asRecord(root.resource)?.url);
+    if (resourceUrl !== null) {
+        for (const t of terms)
+            if (t.resource === null)
+                t.resource = resourceUrl;
+    }
+    return { rail, x402Version, terms, termsHash: hashTerms(terms), malformed: false };
+}
+function challengeFromHeader(headerValue) {
+    let json;
+    try {
+        json = safeBase64Decode(headerValue);
+    }
+    catch {
+        return null;
+    }
+    return parseChallenge(json);
+}
+export function parse402Challenge(rawBody, paymentRequiredHeader) {
+    if (paymentRequiredHeader != null && paymentRequiredHeader.length > 0) {
+        const fromHeader = challengeFromHeader(paymentRequiredHeader);
+        if (fromHeader !== null && !fromHeader.malformed)
+            return fromHeader;
+        const fromBody = parseChallenge(rawBody);
+        if (!fromBody.malformed)
+            return fromBody;
+        return fromHeader ?? fromBody;
+    }
+    return parseChallenge(rawBody);
+}
+function toJson(rawBody) {
+    if (rawBody == null)
+        return null;
+    if (typeof rawBody === "string")
+        return tryParseJson(rawBody);
+    if (rawBody instanceof Uint8Array) {
+        let text;
+        try {
+            text = new TextDecoder("utf-8", { fatal: false }).decode(rawBody);
+        }
+        catch {
+            return null;
+        }
+        return tryParseJson(text);
+    }
+    if (typeof rawBody === "object")
+        return rawBody;
+    return null;
+}
+function tryParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "null";
+    if (Array.isArray(value))
+        return `[${value.map((v) => stableStringify(v)).join(",")}]`;
+    const rec = value;
+    const keys = Object.keys(rec).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(rec[k])}`).join(",")}}`;
+}

package/dist/src/payer/signer_cdp.d.ts

@@ -0,0 +1,14 @@
+import type { Eip712TypedData, WalletSigner } from "./types.js";
+export type CdpSignerConfig = {
+    apiKeyId: string;
+    apiKeySecret: string;
+    walletSecret: string;
+    accountName?: string;
+};
+export declare class CdpServerWalletSigner implements WalletSigner {
+    #private;
+    readonly kind: "cdp_server_wallet";
+    constructor(config: CdpSignerConfig);
+    address(): Promise<string>;
+    signTypedData(td: Eip712TypedData): Promise<`0x${string}`>;
+}

package/dist/src/payer/signer_cdp.js

@@ -0,0 +1,64 @@
+import { CdpClient } from "@coinbase/cdp-sdk";
+import { DEFAULT_CDP_ACCOUNT_NAME } from "../core/constants.js";
+export class CdpServerWalletSigner {
+    kind = "cdp_server_wallet";
+    #apiKeyId;
+    #apiKeySecret;
+    #walletSecret;
+    #accountName;
+    #accountPromise = null;
+    constructor(config) {
+        this.#apiKeyId = config.apiKeyId;
+        this.#apiKeySecret = config.apiKeySecret;
+        this.#walletSecret = config.walletSecret;
+        this.#accountName =
+            config.accountName && config.accountName.length > 0
+                ? config.accountName
+                : DEFAULT_CDP_ACCOUNT_NAME;
+    }
+    async address() {
+        const account = await this.#account();
+        return account.address.toLowerCase();
+    }
+    async signTypedData(td) {
+        const account = await this.#account();
+        try {
+            return await account.signTypedData(td);
+        }
+        catch (err) {
+            throw this.#scrubbedError(err, "CDP signTypedData failed");
+        }
+    }
+    #account() {
+        if (this.#accountPromise === null) {
+            this.#accountPromise = this.#connect().catch((err) => {
+                this.#accountPromise = null;
+                throw this.#scrubbedError(err, "CDP account resolution failed");
+            });
+        }
+        return this.#accountPromise;
+    }
+    async #connect() {
+        const cdp = new CdpClient({
+            apiKeyId: this.#apiKeyId,
+            apiKeySecret: this.#apiKeySecret,
+            walletSecret: this.#walletSecret,
+        });
+        return cdp.evm.getOrCreateAccount({ name: this.#accountName });
+    }
+    #scrubbedError(err, context) {
+        const raw = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+        return new Error(`${context}: ${this.#scrub(raw)}`);
+    }
+    #scrub(text) {
+        let out = text;
+        for (const secret of [this.#apiKeySecret, this.#walletSecret, this.#apiKeyId]) {
+            if (secret && secret.length > 0)
+                out = out.split(secret).join("[redacted]");
+        }
+        out = out.replace(/-----BEGIN[\s\S]*?PRIVATE KEY-----[\s\S]*?-----END[\s\S]*?PRIVATE KEY-----/g, "[redacted-pem]");
+        out = out.replace(/\b(?:0x)?[0-9a-fA-F]{32,}\b/g, "[redacted-hex]");
+        out = out.replace(/\b[A-Za-z0-9_-]{40,}\b/g, "[redacted-token]");
+        return out;
+    }
+}

package/dist/src/payer/signer_local.d.ts

@@ -0,0 +1,8 @@
+import type { Eip712TypedData, WalletSigner } from "./types.js";
+export declare class LocalKeySigner implements WalletSigner {
+    #private;
+    readonly kind: "local_key";
+    constructor(privateKey: `0x${string}`);
+    address(): Promise<string>;
+    signTypedData(td: Eip712TypedData): Promise<`0x${string}`>;
+}

package/dist/src/payer/signer_local.js

@@ -0,0 +1,14 @@
+import { privateKeyToAccount } from "viem/accounts";
+export class LocalKeySigner {
+    kind = "local_key";
+    #account;
+    constructor(privateKey) {
+        this.#account = privateKeyToAccount(privateKey);
+    }
+    async address() {
+        return this.#account.address.toLowerCase();
+    }
+    async signTypedData(td) {
+        return this.#account.signTypedData(td);
+    }
+}