browser-evm-signer 0.1.0

package/esm/http-server.js

@@ -0,0 +1,341 @@
+import { createServer } from "node:http";
+import { statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { getPort } from "./config.js";
+import { pendingStore as defaultPendingStore } from "./pending-store.js";
+// Store test results for e2e browser testing
+const testResults = new Map();
+/**
+ * Get the path to the bundled web UI
+ */
+function getWebDistPath() {
+    const scriptDir = new URL(".", globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url).pathname;
+    // Try candidate paths in order. Dev build (web/dist) must come before web/
+    // because the web/ source directory also exists and would match statSync.
+    const candidates = [
+        `${scriptDir}../web/dist`, // dev: src/ → web/dist (vite build output)
+        `${scriptDir}../dist/web`, // esbuild: dist/ → dist/web
+        `${scriptDir}../web`, // dnt: esm/ → package root → web/ (contains built assets)
+    ];
+    for (const candidate of candidates) {
+        try {
+            statSync(candidate);
+            return candidate;
+        }
+        catch {
+            // try next
+        }
+    }
+    // Fallback — will fail later with a clear error from serveStaticFile
+    return candidates[0];
+}
+/**
+ * Serve static files from the web dist directory
+ */
+async function serveStaticFile(path, webDistPath) {
+    // Default to index.html for SPA routing
+    let filePath = path === "/" || path === "" ? "/index.html" : path;
+    // Remove leading slash and sanitize
+    filePath = filePath.replace(/^\/+/, "").replace(/\.\./g, "");
+    const fullPath = `${webDistPath}/${filePath}`;
+    try {
+        const file = new Uint8Array(await readFile(fullPath));
+        const contentType = getContentType(filePath);
+        return new Response(file, {
+            headers: {
+                "Content-Type": contentType,
+                "Cache-Control": "no-cache",
+            },
+        });
+    }
+    catch {
+        // For SPA, serve index.html for any unknown path
+        if (!filePath.includes(".")) {
+            try {
+                const indexHtml = new Uint8Array(await readFile(`${webDistPath}/index.html`));
+                return new Response(indexHtml, {
+                    headers: {
+                        "Content-Type": "text/html",
+                        "Cache-Control": "no-cache",
+                    },
+                });
+            }
+            catch {
+                return new Response("Web UI not found. Run 'deno task build:web' first.", {
+                    status: 404,
+                });
+            }
+        }
+        return new Response("Not found", { status: 404 });
+    }
+}
+/**
+ * Get content type from file extension
+ */
+function getContentType(path) {
+    const ext = path.split(".").pop()?.toLowerCase();
+    const types = {
+        html: "text/html",
+        js: "application/javascript",
+        mjs: "application/javascript",
+        css: "text/css",
+        json: "application/json",
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        svg: "image/svg+xml",
+        ico: "image/x-icon",
+        woff: "font/woff",
+        woff2: "font/woff2",
+        ttf: "font/ttf",
+    };
+    return types[ext || ""] || "application/octet-stream";
+}
+/**
+ * Handle API requests
+ */
+function handleApiRequest(pathname, method, body, store) {
+    const corsHeaders = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+    };
+    // Handle CORS preflight
+    if (method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: corsHeaders });
+    }
+    // GET /api/pending/:id - Get pending request details
+    const pendingMatch = pathname.match(/^\/api\/pending\/([a-f0-9-]+)$/);
+    if (pendingMatch && method === "GET") {
+        const id = pendingMatch[1];
+        const request = store.get(id);
+        if (!request) {
+            return new Response(JSON.stringify({ error: "Request not found" }), {
+                status: 404,
+                headers: { ...corsHeaders, "Content-Type": "application/json" },
+            });
+        }
+        const response = { request };
+        return new Response(JSON.stringify(response), {
+            headers: { ...corsHeaders, "Content-Type": "application/json" },
+        });
+    }
+    // POST /api/complete/:id - Complete a pending request
+    const completeMatch = pathname.match(/^\/api\/complete\/([a-f0-9-]+)$/);
+    if (completeMatch && method === "POST") {
+        const id = completeMatch[1];
+        if (!store.has(id)) {
+            return new Response(JSON.stringify({ error: "Request not found" }), {
+                status: 404,
+                headers: { ...corsHeaders, "Content-Type": "application/json" },
+            });
+        }
+        const data = body;
+        if (typeof data.success !== "boolean") {
+            return new Response(JSON.stringify({ error: "Invalid request body" }), {
+                status: 400,
+                headers: { ...corsHeaders, "Content-Type": "application/json" },
+            });
+        }
+        const result = data.success
+            ? { success: true, result: data.result || "" }
+            : { success: false, error: data.error || "Unknown error" };
+        const completed = store.complete(id, result);
+        if (!completed) {
+            return new Response(JSON.stringify({ error: "Failed to complete request" }), {
+                status: 500,
+                headers: { ...corsHeaders, "Content-Type": "application/json" },
+            });
+        }
+        return new Response(JSON.stringify({ ok: true }), {
+            headers: { ...corsHeaders, "Content-Type": "application/json" },
+        });
+    }
+    // GET /api/health - Health check
+    if (pathname === "/api/health" && method === "GET") {
+        return new Response(JSON.stringify({
+            status: "ok",
+            pendingRequests: store.size,
+        }), {
+            headers: { ...corsHeaders, "Content-Type": "application/json" },
+        });
+    }
+    // === Test endpoints (for e2e browser testing) ===
+    // POST /api/test/create-request - Create a pending request for testing
+    if (pathname === "/api/test/create-request" && method === "POST") {
+        const data = body;
+        const type = data.type;
+        let id;
+        let promise;
+        switch (type) {
+            case "connect": {
+                const result = store.createConnectRequest({
+                    chainId: data.chainId,
+                    address: data.address,
+                });
+                id = result.id;
+                promise = result.promise;
+                break;
+            }
+            case "send_transaction": {
+                const result = store.createSendTransactionRequest({
+                    to: data.to,
+                    value: data.value,
+                    data: data.data,
+                    chainId: data.chainId,
+                    gasLimit: data.gasLimit,
+                    maxFeePerGas: data.maxFeePerGas,
+                    maxPriorityFeePerGas: data.maxPriorityFeePerGas,
+                });
+                id = result.id;
+                promise = result.promise;
+                break;
+            }
+            case "sign_message": {
+                const result = store.createSignMessageRequest({
+                    message: data.message,
+                    address: data.address,
+                    chainId: data.chainId,
+                });
+                id = result.id;
+                promise = result.promise;
+                break;
+            }
+            case "sign_typed_data": {
+                const result = store.createSignTypedDataRequest({
+                    domain: data.domain,
+                    types: data.types,
+                    primaryType: data.primaryType,
+                    message: data.message,
+                    address: data.address,
+                    chainId: data.chainId,
+                });
+                id = result.id;
+                promise = result.promise;
+                break;
+            }
+            default:
+                return new Response(JSON.stringify({ error: "Invalid request type" }), {
+                    status: 400,
+                    headers: { ...corsHeaders, "Content-Type": "application/json" },
+                });
+        }
+        // Store the promise result for later retrieval
+        promise.then((result) => {
+            testResults.set(id, result);
+        }).catch((err) => {
+            testResults.set(id, { success: false, error: err.message });
+        });
+        return new Response(JSON.stringify({ id }), {
+            headers: { ...corsHeaders, "Content-Type": "application/json" },
+        });
+    }
+    // GET /api/test/result/:id - Get test result
+    const testResultMatch = pathname.match(/^\/api\/test\/result\/([a-f0-9-]+)$/);
+    if (testResultMatch && method === "GET") {
+        const id = testResultMatch[1];
+        const result = testResults.get(id);
+        if (result === undefined) {
+            // Check if request is still pending
+            if (store.has(id)) {
+                return new Response(JSON.stringify({ pending: true }), {
+                    headers: { ...corsHeaders, "Content-Type": "application/json" },
+                });
+            }
+            return new Response(JSON.stringify({ error: "Result not found" }), {
+                status: 404,
+                headers: { ...corsHeaders, "Content-Type": "application/json" },
+            });
+        }
+        return new Response(JSON.stringify(result), {
+            headers: { ...corsHeaders, "Content-Type": "application/json" },
+        });
+    }
+    return new Response(JSON.stringify({ error: "Not found" }), {
+        status: 404,
+        headers: { ...corsHeaders, "Content-Type": "application/json" },
+    });
+}
+/**
+ * Read the full request body from an IncomingMessage as a string.
+ */
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = "";
+        req.setEncoding("utf8");
+        req.on("data", (chunk) => (body += chunk));
+        req.on("end", () => resolve(body));
+        req.on("error", reject);
+    });
+}
+/**
+ * Write a web-standard Response to a Node ServerResponse.
+ */
+async function writeResponse(res, response) {
+    res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+    if (response.body) {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        res.end(bytes);
+    }
+    else {
+        res.end();
+    }
+}
+/**
+ * Create a node:http request handler using the existing Response-based logic.
+ */
+function makeHandler(webDistPath, store) {
+    return async (req, res) => {
+        const url = new URL(req.url, `http://${req.headers.host || "127.0.0.1"}`);
+        const pathname = url.pathname;
+        const method = req.method || "GET";
+        let response;
+        if (pathname.startsWith("/api/")) {
+            let body = null;
+            if (method === "POST") {
+                try {
+                    const raw = await readBody(req);
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    response = new Response(JSON.stringify({ error: "Invalid JSON" }), {
+                        status: 400,
+                        headers: { "Content-Type": "application/json" },
+                    });
+                    await writeResponse(res, response);
+                    return;
+                }
+            }
+            response = handleApiRequest(pathname, method, body, store);
+        }
+        else {
+            response = await serveStaticFile(pathname, webDistPath);
+        }
+        await writeResponse(res, response);
+    };
+}
+/**
+ * Create an HTTP server bound to a PendingStore.
+ * Returns the port and a stop function.
+ */
+export async function createHttpServer(store, port) {
+    const targetPort = port ?? getPort();
+    const webDistPath = getWebDistPath();
+    const srv = createServer(makeHandler(webDistPath, store));
+    await new Promise((resolve) => {
+        srv.listen(targetPort, "127.0.0.1", () => resolve());
+    });
+    const actualPort = srv.address().port;
+    return {
+        port: actualPort,
+        stop: () => new Promise((resolve, reject) => {
+            srv.close((err) => (err ? reject(err) : resolve()));
+        }),
+    };
+}
+/**
+ * Start a test server on a random port using the default PendingStore.
+ */
+export function startTestServer() {
+    return createHttpServer(defaultPendingStore, 0);
+}

package/esm/mod.d.ts

@@ -0,0 +1,11 @@
+import "./_dnt.polyfills.js";
+export { type BalanceResult, type ConnectResult, type SendTransactionParams, type SignMessageParams, type SignResult, type SignTypedDataParams, type TransactionResult, WalletSigner, type WalletSignerOptions, } from "./wallet-signer.js";
+export { CHAINS, getChainConfig, getDefaultChainId, getPort, getRpcUrl } from "./config.js";
+export type { ChainConfig, TypedDataDomain, TypedDataField } from "./types.js";
+export { walletSignerTransport, type WalletSignerTransportOptions } from "./transport.js";
+export { connectWalletViem, type ConnectWalletViemOptions, type ViemBrowserAccount } from "./viem-account.js";
+export { PendingStore, pendingStore } from "./pending-store.js";
+export { createHttpServer, startTestServer } from "./http-server.js";
+export { buildConnectUrl, buildSignUrl, openBrowser } from "./browser.js";
+export { VERSION } from "./version.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,UAAU,EACf,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,YAAY,EACZ,KAAK,mBAAmB,GACzB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,iBAAiB,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC5F,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE/E,OAAO,EAAE,qBAAqB,EAAE,KAAK,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE9G,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/esm/mod.js

@@ -0,0 +1,9 @@
+import "./_dnt.polyfills.js";
+export { WalletSigner, } from "./wallet-signer.js";
+export { CHAINS, getChainConfig, getDefaultChainId, getPort, getRpcUrl } from "./config.js";
+export { walletSignerTransport } from "./transport.js";
+export { connectWalletViem } from "./viem-account.js";
+export { PendingStore, pendingStore } from "./pending-store.js";
+export { createHttpServer, startTestServer } from "./http-server.js";
+export { buildConnectUrl, buildSignUrl, openBrowser } from "./browser.js";
+export { VERSION } from "./version.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/pending-store.d.ts

@@ -0,0 +1,89 @@
+import type { PendingRequest, RequestResult, SignTypedDataRequest } from "./types.js";
+/**
+ * Store for pending signing requests.
+ * Each request creates a Promise that resolves when the browser completes the signing.
+ */
+export declare class PendingStore {
+    private pending;
+    private timeouts;
+    /**
+     * Create a new connect wallet request
+     */
+    createConnectRequest(params?: {
+        chainId?: number;
+        address?: string;
+    }): {
+        id: string;
+        promise: Promise<RequestResult>;
+    };
+    /**
+     * Create a new send transaction request
+     */
+    createSendTransactionRequest(params: {
+        to: string;
+        value?: string;
+        data?: string;
+        chainId?: number;
+        gasLimit?: string;
+        maxFeePerGas?: string;
+        maxPriorityFeePerGas?: string;
+    }): {
+        id: string;
+        promise: Promise<RequestResult>;
+    };
+    /**
+     * Create a new sign message request
+     */
+    createSignMessageRequest(params: {
+        message: string;
+        address?: string;
+        chainId?: number;
+    }): {
+        id: string;
+        promise: Promise<RequestResult>;
+    };
+    /**
+     * Create a new sign typed data request
+     */
+    createSignTypedDataRequest(params: {
+        domain: SignTypedDataRequest["domain"];
+        types: SignTypedDataRequest["types"];
+        primaryType: string;
+        message: Record<string, unknown>;
+        address?: string;
+        chainId?: number;
+    }): {
+        id: string;
+        promise: Promise<RequestResult>;
+    };
+    /**
+     * Create a pending request and return a Promise that resolves when completed
+     */
+    private create;
+    /**
+     * Get a pending request by ID
+     */
+    get(id: string): PendingRequest | undefined;
+    /**
+     * Complete a pending request with a result
+     */
+    complete(id: string, result: RequestResult): boolean;
+    /**
+     * Cancel a pending request
+     */
+    cancel(id: string, reason?: string): boolean;
+    /**
+     * Check if a request is pending
+     */
+    has(id: string): boolean;
+    /**
+     * Get all pending request IDs
+     */
+    getPendingIds(): string[];
+    /**
+     * Get count of pending requests
+     */
+    get size(): number;
+}
+export declare const pendingStore: PendingStore;
+//# sourceMappingURL=pending-store.d.ts.map

package/esm/pending-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-store.d.ts","sourceRoot":"","sources":["../src/pending-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EACd,aAAa,EAGb,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAUpB;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAwC;IACvD,OAAO,CAAC,QAAQ,CAAkC;IAElD;;OAEG;IACH,oBAAoB,CAAC,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;KAAE;IAWtH;;OAEG;IACH,4BAA4B,CAAC,MAAM,EAAE;QACnC,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,oBAAoB,CAAC,EAAE,MAAM,CAAC;KAC/B,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;KAAE;IAUnD;;OAEG;IACH,wBAAwB,CAAC,MAAM,EAAE;QAC/B,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;KAAE;IAUnD;;OAEG;IACH,0BAA0B,CAAC,MAAM,EAAE;QACjC,MAAM,EAAE,oBAAoB,CAAC,QAAQ,CAAC,CAAC;QACvC,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;QACrC,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACjC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;KAAE;IAUnD;;OAEG;IACH,OAAO,CAAC,MAAM;IAwBd;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI3C;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO;IAmBpD;;OAEG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO;IAmB5C;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,MAAM,EAAE;IAIzB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAGD,eAAO,MAAM,YAAY,cAAqB,CAAC"}

package/esm/pending-store.js

@@ -0,0 +1,162 @@
+// Generates a unique request ID
+function generateId() {
+    return crypto.randomUUID();
+}
+// Timeout for pending requests (5 minutes)
+const REQUEST_TIMEOUT_MS = 5 * 60 * 1000;
+/**
+ * Store for pending signing requests.
+ * Each request creates a Promise that resolves when the browser completes the signing.
+ */
+export class PendingStore {
+    constructor() {
+        Object.defineProperty(this, "pending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "timeouts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Create a new connect wallet request
+     */
+    createConnectRequest(params) {
+        const request = {
+            id: generateId(),
+            type: "connect",
+            chainId: params?.chainId,
+            address: params?.address,
+            createdAt: Date.now(),
+        };
+        return this.create(request);
+    }
+    /**
+     * Create a new send transaction request
+     */
+    createSendTransactionRequest(params) {
+        const request = {
+            id: generateId(),
+            type: "send_transaction",
+            createdAt: Date.now(),
+            ...params,
+        };
+        return this.create(request);
+    }
+    /**
+     * Create a new sign message request
+     */
+    createSignMessageRequest(params) {
+        const request = {
+            id: generateId(),
+            type: "sign_message",
+            createdAt: Date.now(),
+            ...params,
+        };
+        return this.create(request);
+    }
+    /**
+     * Create a new sign typed data request
+     */
+    createSignTypedDataRequest(params) {
+        const request = {
+            id: generateId(),
+            type: "sign_typed_data",
+            createdAt: Date.now(),
+            ...params,
+        };
+        return this.create(request);
+    }
+    /**
+     * Create a pending request and return a Promise that resolves when completed
+     */
+    create(request) {
+        const promise = new Promise((resolve, reject) => {
+            const entry = {
+                request,
+                resolve,
+                reject,
+            };
+            this.pending.set(request.id, entry);
+            // Set timeout to auto-reject
+            const timeoutId = setTimeout(() => {
+                if (this.pending.has(request.id)) {
+                    this.pending.delete(request.id);
+                    this.timeouts.delete(request.id);
+                    reject(new Error("Request timed out after 5 minutes"));
+                }
+            }, REQUEST_TIMEOUT_MS);
+            this.timeouts.set(request.id, timeoutId);
+        });
+        return { id: request.id, promise };
+    }
+    /**
+     * Get a pending request by ID
+     */
+    get(id) {
+        return this.pending.get(id)?.request;
+    }
+    /**
+     * Complete a pending request with a result
+     */
+    complete(id, result) {
+        const entry = this.pending.get(id);
+        if (!entry) {
+            return false;
+        }
+        // Clear timeout
+        const timeoutId = this.timeouts.get(id);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            this.timeouts.delete(id);
+        }
+        // Resolve the promise
+        entry.resolve(result);
+        this.pending.delete(id);
+        return true;
+    }
+    /**
+     * Cancel a pending request
+     */
+    cancel(id, reason) {
+        const entry = this.pending.get(id);
+        if (!entry) {
+            return false;
+        }
+        // Clear timeout
+        const timeoutId = this.timeouts.get(id);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            this.timeouts.delete(id);
+        }
+        // Reject the promise
+        entry.reject(new Error(reason || "Request cancelled"));
+        this.pending.delete(id);
+        return true;
+    }
+    /**
+     * Check if a request is pending
+     */
+    has(id) {
+        return this.pending.has(id);
+    }
+    /**
+     * Get all pending request IDs
+     */
+    getPendingIds() {
+        return Array.from(this.pending.keys());
+    }
+    /**
+     * Get count of pending requests
+     */
+    get size() {
+        return this.pending.size;
+    }
+}
+// Singleton instance
+export const pendingStore = new PendingStore();

package/esm/transport.d.ts

@@ -0,0 +1,9 @@
+import type { CustomTransport } from "viem";
+import type { WalletSigner } from "./wallet-signer.js";
+export interface WalletSignerTransportOptions {
+    /** JSON-RPC endpoint for chain-reading calls. Defaults to built-in RPC for the signer's default chain. */
+    rpcUrl?: string;
+}
+/** Create a viem custom transport that routes wallet methods through WalletSigner. */
+export declare function walletSignerTransport(signer: WalletSigner, options?: WalletSignerTransportOptions): CustomTransport;
+//# sourceMappingURL=transport.d.ts.map

package/esm/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAE5C,OAAO,KAAK,EAAyB,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAG9E,MAAM,WAAW,4BAA4B;IAC3C,0GAA0G;IAC1G,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,sFAAsF;AACtF,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,4BAA4B,GACrC,eAAe,CAyDjB"}