site-agent-pro 1.0.0

package/dist/wallet/provider.js

@@ -0,0 +1,345 @@
+/**
+ * Builds a JavaScript source string that, when evaluated in a browser page via
+ * `context.addInitScript()`, installs a minimal EIP-1193-compatible
+ * `window.ethereum` provider backed by the agent's server-side signing relay.
+ *
+ * The injected provider:
+ *  - Auto-connects (returns the agent address for `eth_requestAccounts`)
+ *  - Proxies read-only RPC calls to the configured JSON-RPC endpoint
+ *  - Delegates signing operations to the local signing relay running on `relayPort`
+ *  - Emits EIP-1193 events (`connect`, `accountsChanged`, `chainChanged`)
+ *  - Reports `isMetaMask = true` for dApp compatibility
+ */
+export function buildWeb3InjectionScript(args) {
+    const { walletConfig, relayPort } = args;
+    const address = walletConfig.address.toLowerCase();
+    const chainIdHex = `0x${walletConfig.chainId.toString(16)}`;
+    const rpcUrl = walletConfig.rpcUrl;
+    const relayOrigin = `http://127.0.0.1:${relayPort}`;
+    // The entire script is a self-executing IIFE injected before any page JS runs.
+    return `(function() {
+  "use strict";
+
+  if (window.ethereum && window.ethereum.__siteAgentInjected) {
+    return;
+  }
+
+  var AGENT_ADDRESS = ${JSON.stringify(address)};
+  var CHAIN_ID_HEX = ${JSON.stringify(chainIdHex)};
+  var CHAIN_ID_DEC = ${walletConfig.chainId};
+  var RPC_URL = ${JSON.stringify(rpcUrl)};
+  var RELAY_ORIGIN = ${JSON.stringify(relayOrigin)};
+  var connected = true;
+  var upstreamEthereum = window.ethereum && !window.ethereum.__siteAgentInjected ? window.ethereum : null;
+
+  /* ----- Event emitter ----- */
+  var listeners = {};
+
+  function on(event, fn) {
+    if (!listeners[event]) listeners[event] = [];
+    listeners[event].push(fn);
+  }
+
+  function removeListener(event, fn) {
+    if (!listeners[event]) return;
+    listeners[event] = listeners[event].filter(function(f) { return f !== fn; });
+  }
+
+  function emit(event) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    (listeners[event] || []).forEach(function(fn) {
+      try { fn.apply(null, args); } catch(e) { console.warn("[site-agent-wallet] listener error:", e); }
+    });
+  }
+
+  /* ----- JSON-RPC helpers ----- */
+  var rpcId = 1;
+
+  function rpcCall(method, params) {
+    return fetch(RPC_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: rpcId++, method: method, params: params || [] })
+    })
+    .then(function(res) { return res.json(); })
+    .then(function(json) {
+      if (json.error) throw new Error(json.error.message || "RPC error");
+      return json.result;
+    });
+  }
+
+  function relayCall(endpoint, body) {
+    return fetch(RELAY_ORIGIN + endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    })
+    .then(function(res) { return res.json(); })
+    .then(function(json) {
+      if (json.error) throw new Error(json.error);
+      return json.result;
+    });
+  }
+
+  function maybeCaptureUpstreamEthereum(candidate) {
+    if (!candidate || candidate === provider || candidate.__siteAgentInjected) {
+      return;
+    }
+
+    if (
+      !upstreamEthereum ||
+      candidate.isMetaMask ||
+      (candidate._metamask && typeof candidate._metamask.isUnlocked === "function")
+    ) {
+      upstreamEthereum = candidate;
+    }
+  }
+
+  function getUpstreamEthereum() {
+    if (!upstreamEthereum && window.ethereum && window.ethereum !== provider && !window.ethereum.__siteAgentInjected) {
+      maybeCaptureUpstreamEthereum(window.ethereum);
+    }
+
+    if (!upstreamEthereum && window.ethereum && Array.isArray(window.ethereum.providers)) {
+      var announcedMetaMaskProvider = window.ethereum.providers.find(function(candidate) {
+        return candidate && candidate !== provider && (candidate.isMetaMask || candidate._metamask);
+      });
+      maybeCaptureUpstreamEthereum(announcedMetaMaskProvider);
+    }
+
+    return upstreamEthereum && upstreamEthereum !== provider ? upstreamEthereum : null;
+  }
+
+  /* ----- EIP-1193 request handler ----- */
+  function request(args) {
+    var method = args.method;
+    var params = args.params || [];
+    var originalEthereum = getUpstreamEthereum();
+
+    switch (method) {
+      case "eth_requestAccounts":
+      case "eth_accounts":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args);
+        }
+        return Promise.resolve([AGENT_ADDRESS]);
+
+      case "eth_chainId":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args).catch(function() { return CHAIN_ID_HEX; });
+        }
+        return Promise.resolve(CHAIN_ID_HEX);
+
+      case "net_version":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args).catch(function() { return String(CHAIN_ID_DEC); });
+        }
+        return Promise.resolve(String(CHAIN_ID_DEC));
+
+      case "wallet_switchEthereumChain":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args);
+        }
+        /* Accept any chain switch silently — the relay always uses the configured chain */
+        emit("chainChanged", CHAIN_ID_HEX);
+        return Promise.resolve(null);
+
+      case "wallet_addEthereumChain":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args);
+        }
+        emit("chainChanged", CHAIN_ID_HEX);
+        return Promise.resolve(null);
+
+      case "wallet_requestPermissions":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args);
+        }
+        return Promise.resolve([{ parentCapability: "eth_accounts" }]);
+
+      case "wallet_watchAsset":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args);
+        }
+        return Promise.resolve(true);
+
+      case "eth_sendTransaction":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args);
+        }
+        return relayCall("/send-transaction", { tx: params[0] });
+
+      case "personal_sign":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args);
+        }
+        return relayCall("/sign-message", { message: params[0], address: params[1] });
+
+      case "eth_sign":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args);
+        }
+        return relayCall("/sign-message", { message: params[1], address: params[0] });
+
+      case "eth_signTypedData":
+      case "eth_signTypedData_v3":
+      case "eth_signTypedData_v4":
+        if (originalEthereum && originalEthereum.request) {
+           return originalEthereum.request(args);
+        }
+        var typedDataParam = typeof params[1] === "string" ? JSON.parse(params[1]) : params[1];
+        return relayCall("/sign-typed-data", { data: typedDataParam });
+
+      /* Read-only calls — proxy directly to the RPC endpoint */
+      case "eth_getBalance":
+      case "eth_blockNumber":
+      case "eth_call":
+      case "eth_estimateGas":
+      case "eth_gasPrice":
+      case "eth_getTransactionCount":
+      case "eth_getTransactionReceipt":
+      case "eth_getTransactionByHash":
+      case "eth_getCode":
+      case "eth_getStorageAt":
+      case "eth_getLogs":
+      case "eth_getBlockByNumber":
+      case "eth_getBlockByHash":
+      case "eth_feeHistory":
+      case "eth_maxPriorityFeePerGas":
+        return rpcCall(method, params);
+
+      default:
+        /* Attempt to proxy unknown methods to RPC — some dApps use non-standard calls */
+        return rpcCall(method, params);
+    }
+  }
+
+  /* ----- Legacy send / sendAsync ----- */
+  function send(methodOrPayload, callbackOrParams) {
+    if (typeof methodOrPayload === "string") {
+      return request({ method: methodOrPayload, params: callbackOrParams || [] });
+    }
+    /* JSON-RPC payload object with callback */
+    if (typeof callbackOrParams === "function") {
+      request({ method: methodOrPayload.method, params: methodOrPayload.params || [] })
+        .then(function(result) { callbackOrParams(null, { id: methodOrPayload.id, jsonrpc: "2.0", result: result }); })
+        .catch(function(err) { callbackOrParams(err, null); });
+      return;
+    }
+    return request({ method: methodOrPayload.method, params: methodOrPayload.params || [] });
+  }
+
+  function sendAsync(payload, callback) {
+    request({ method: payload.method, params: payload.params || [] })
+      .then(function(result) { callback(null, { id: payload.id, jsonrpc: "2.0", result: result }); })
+      .catch(function(err) { callback(err, null); });
+  }
+
+  /* ----- Provider object ----- */
+  var provider = {
+    isMetaMask: true,
+    __siteAgentInjected: true,
+    get chainId() {
+      var originalEthereum = getUpstreamEthereum();
+      return originalEthereum && originalEthereum.chainId ? originalEthereum.chainId : CHAIN_ID_HEX;
+    },
+    get networkVersion() {
+      var originalEthereum = getUpstreamEthereum();
+      return originalEthereum && originalEthereum.networkVersion ? originalEthereum.networkVersion : String(CHAIN_ID_DEC);
+    },
+    get selectedAddress() {
+      var originalEthereum = getUpstreamEthereum();
+      return originalEthereum && originalEthereum.selectedAddress ? originalEthereum.selectedAddress : AGENT_ADDRESS;
+    },
+    isConnected: function() {
+      var originalEthereum = getUpstreamEthereum();
+      return originalEthereum && typeof originalEthereum.isConnected === "function"
+        ? originalEthereum.isConnected()
+        : connected;
+    },
+    request: request,
+    send: send,
+    sendAsync: sendAsync,
+    on: on,
+    removeListener: removeListener,
+    removeAllListeners: function(event) {
+      if (event) { listeners[event] = []; }
+      else { listeners = {}; }
+    },
+    /* Some dApps access these */
+    enable: function() { return request({ method: "eth_requestAccounts" }); },
+    _metamask: {
+      isUnlocked: function() {
+        var originalEthereum = getUpstreamEthereum();
+        if (originalEthereum && originalEthereum._metamask && typeof originalEthereum._metamask.isUnlocked === "function") {
+          return originalEthereum._metamask.isUnlocked();
+        }
+        return Promise.resolve(true);
+      }
+    }
+  };
+
+  try {
+    window.addEventListener("eip6963:announceProvider", function(event) {
+      var detail = event && event.detail ? event.detail : null;
+      if (!detail || detail.provider === provider) {
+        return;
+      }
+
+      var info = detail.info || {};
+      if (info.rdns === "com.siteagent.wallet") {
+        return;
+      }
+
+      if (info.rdns === "io.metamask" || /metamask/i.test(info.name || "") || detail.provider.isMetaMask) {
+        maybeCaptureUpstreamEthereum(detail.provider);
+      }
+    });
+  } catch(e) { /* Provider discovery listener is optional */ }
+
+  /* Announce the provider using EIP-6963 for modern dApps */
+  try {
+    window.dispatchEvent(new CustomEvent("eip6963:announceProvider", {
+      detail: Object.freeze({
+        info: {
+          uuid: "site-agent-wallet-00000000",
+          name: "Site Agent Wallet",
+          icon: "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'/>",
+          rdns: "com.siteagent.wallet"
+        },
+        provider: provider
+      })
+    }));
+    /* Listen for discovery requests */
+    window.addEventListener("eip6963:requestProvider", function() {
+      window.dispatchEvent(new CustomEvent("eip6963:announceProvider", {
+        detail: Object.freeze({
+          info: {
+            uuid: "site-agent-wallet-00000000",
+            name: "Site Agent Wallet",
+            icon: "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'/>",
+            rdns: "com.siteagent.wallet"
+          },
+          provider: provider
+        })
+      }));
+    });
+  } catch(e) { /* EIP-6963 not critical */ }
+
+  /* Install as window.ethereum */
+  Object.defineProperty(window, "ethereum", {
+    configurable: true,
+    enumerable: true,
+    get: function() { return provider; },
+    set: function(candidate) { maybeCaptureUpstreamEthereum(candidate); }
+  });
+
+  /* Fire initial connect event on next tick */
+  setTimeout(function() {
+    emit("connect", { chainId: CHAIN_ID_HEX });
+    emit("accountsChanged", [AGENT_ADDRESS]);
+  }, 0);
+
+  console.log("[site-agent-wallet] Injected Web3 provider — address:", AGENT_ADDRESS, "chain:", CHAIN_ID_DEC);
+})();`;
+}

package/dist/wallet/relay.js

@@ -0,0 +1,129 @@
+import http from "node:http";
+import { signMessage, signTypedData, sendTransaction } from "./wallet.js";
+import { debug } from "../utils/log.js";
+/* ------------------------------------------------------------------ */
+/*  Request parsing helpers                                            */
+/* ------------------------------------------------------------------ */
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+        req.on("error", reject);
+    });
+}
+function jsonResponse(res, statusCode, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(statusCode, {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type"
+    });
+    res.end(payload);
+}
+/* ------------------------------------------------------------------ */
+/*  Route handlers                                                     */
+/* ------------------------------------------------------------------ */
+async function handleSignMessage(body) {
+    const message = body.message;
+    if (typeof message !== "string") {
+        throw new Error("Missing or invalid 'message' field.");
+    }
+    debug("signing relay: sign-message request");
+    return signMessage(message);
+}
+async function handleSignTypedData(body) {
+    const data = body.data;
+    if (!data || typeof data !== "object") {
+        throw new Error("Missing or invalid 'data' field.");
+    }
+    debug("signing relay: sign-typed-data request");
+    // EIP-712 typed data comes in { domain, types, message, primaryType }
+    const domain = data.domain ?? {};
+    const types = { ...data.types };
+    // Remove EIP712Domain from types — ethers adds it automatically
+    delete types["EIP712Domain"];
+    const value = data.message ?? {};
+    return signTypedData(domain, types, value);
+}
+async function handleSendTransaction(body) {
+    const tx = body.tx;
+    if (!tx || typeof tx !== "object") {
+        throw new Error("Missing or invalid 'tx' field.");
+    }
+    debug("signing relay: send-transaction request", { to: tx.to, value: tx.value });
+    return sendTransaction(tx);
+}
+/* ------------------------------------------------------------------ */
+/*  Server                                                             */
+/* ------------------------------------------------------------------ */
+export function startSigningRelay() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            // CORS preflight
+            if (req.method === "OPTIONS") {
+                res.writeHead(204, {
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Methods": "POST, OPTIONS",
+                    "Access-Control-Allow-Headers": "Content-Type"
+                });
+                res.end();
+                return;
+            }
+            if (req.method !== "POST") {
+                jsonResponse(res, 405, { error: "Method not allowed" });
+                return;
+            }
+            try {
+                const rawBody = await readBody(req);
+                const body = JSON.parse(rawBody);
+                let result;
+                switch (req.url) {
+                    case "/sign-message":
+                        result = await handleSignMessage(body);
+                        break;
+                    case "/sign-typed-data":
+                        result = await handleSignTypedData(body);
+                        break;
+                    case "/send-transaction":
+                        result = await handleSendTransaction(body);
+                        break;
+                    default:
+                        jsonResponse(res, 404, { error: `Unknown endpoint: ${req.url}` });
+                        return;
+                }
+                jsonResponse(res, 200, { result });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                debug("signing relay: request error", { url: req.url, error: message });
+                jsonResponse(res, 500, { error: message });
+            }
+        });
+        // Bind to a random available port on localhost only
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                server.close();
+                reject(new Error("Failed to resolve signing relay address."));
+                return;
+            }
+            const port = addr.port;
+            debug("signing relay: started on 127.0.0.1:" + port);
+            resolve({
+                port,
+                close: () => new Promise((resolveClose) => {
+                    server.close(() => {
+                        debug("signing relay: stopped");
+                        resolveClose();
+                    });
+                })
+            });
+        });
+        server.on("error", (error) => {
+            reject(new Error(`Signing relay failed to start: ${error.message}`));
+        });
+    });
+}

package/dist/wallet/wallet.js

@@ -0,0 +1,178 @@
+import { z } from "zod";
+import dotenv from "dotenv";
+dotenv.config();
+/* ------------------------------------------------------------------ */
+/*  Environment schema                                                 */
+/* ------------------------------------------------------------------ */
+function normalizeOptionalString(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    // Strip surrounding quotes if they exist
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim() || undefined;
+    }
+    return trimmed;
+}
+const WalletEnvSchema = z.object({
+    WALLET_PRIVATE_KEY: z
+        .string()
+        .optional()
+        .transform((value) => normalizeOptionalString(value)),
+    WALLET_MNEMONIC: z
+        .string()
+        .optional()
+        .transform((value) => normalizeOptionalString(value)),
+    WALLET_RPC_URL: z
+        .string()
+        .optional()
+        .transform((value) => normalizeOptionalString(value)),
+    WALLET_CHAIN_ID: z.coerce.number().int().positive().default(11155111),
+    WALLET_METAMASK_EXTENSION_PATH: z
+        .string()
+        .optional()
+        .transform((value) => normalizeOptionalString(value)),
+    WALLET_METAMASK_USER_DATA_DIR: z
+        .string()
+        .optional()
+        .transform((value) => normalizeOptionalString(value))
+});
+const walletOverrides = {};
+function getWalletEnv() {
+    const base = WalletEnvSchema.parse(process.env);
+    return {
+        ...base,
+        ...walletOverrides
+    };
+}
+export function updateWalletSettings(updates) {
+    Object.assign(walletOverrides, updates);
+}
+/* ------------------------------------------------------------------ */
+/*  Lazy singleton                                                     */
+/* ------------------------------------------------------------------ */
+let cachedEthers = null;
+let cachedWallet = null;
+async function loadEthers() {
+    if (cachedEthers) {
+        return cachedEthers;
+    }
+    const mod = (await import("ethers"));
+    cachedEthers = mod.default ?? mod;
+    return cachedEthers;
+}
+async function resolveWallet() {
+    if (cachedWallet) {
+        return cachedWallet;
+    }
+    const ethers = await loadEthers();
+    const env = getWalletEnv();
+    const rpcUrl = env.WALLET_RPC_URL;
+    if (!rpcUrl) {
+        throw new Error("WALLET_RPC_URL is required when a wallet private key or mnemonic is configured.");
+    }
+    const provider = new ethers.JsonRpcProvider(rpcUrl);
+    if (env.WALLET_PRIVATE_KEY) {
+        const key = env.WALLET_PRIVATE_KEY.startsWith("0x")
+            ? env.WALLET_PRIVATE_KEY
+            : `0x${env.WALLET_PRIVATE_KEY}`;
+        cachedWallet = new ethers.Wallet(key, provider);
+        return cachedWallet;
+    }
+    if (env.WALLET_MNEMONIC) {
+        const mnemonic = ethers.Mnemonic.fromPhrase(env.WALLET_MNEMONIC);
+        const hdWallet = ethers.HDNodeWallet.fromMnemonic(mnemonic);
+        // HDNodeWallet needs to be reconnected with the provider
+        cachedWallet = new ethers.Wallet(hdWallet.privateKey, provider);
+        return cachedWallet;
+    }
+    throw new Error("Either WALLET_PRIVATE_KEY or WALLET_MNEMONIC must be set.");
+}
+/* ------------------------------------------------------------------ */
+/*  Public API                                                         */
+/* ------------------------------------------------------------------ */
+export function isWalletConfigured() {
+    return Boolean((getWalletEnv().WALLET_PRIVATE_KEY || getWalletEnv().WALLET_MNEMONIC) && getWalletEnv().WALLET_RPC_URL);
+}
+export function getWalletChainId() {
+    return getWalletEnv().WALLET_CHAIN_ID;
+}
+export function getMetaMaskExtensionPath() {
+    return getWalletEnv().WALLET_METAMASK_EXTENSION_PATH;
+}
+export function getMetaMaskUserDataDir() {
+    return getWalletEnv().WALLET_METAMASK_USER_DATA_DIR;
+}
+export async function getWalletConfig() {
+    if (!isWalletConfigured()) {
+        return null;
+    }
+    const wallet = await resolveWallet();
+    return {
+        address: wallet.address,
+        chainId: getWalletEnv().WALLET_CHAIN_ID,
+        rpcUrl: getWalletEnv().WALLET_RPC_URL,
+        metamaskExtensionPath: getWalletEnv().WALLET_METAMASK_EXTENSION_PATH,
+        metamaskUserDataDir: getWalletEnv().WALLET_METAMASK_USER_DATA_DIR
+    };
+}
+export async function getWalletAddress() {
+    const wallet = await resolveWallet();
+    return wallet.address;
+}
+export async function getWalletProvider() {
+    const wallet = await resolveWallet();
+    return wallet.provider;
+}
+export async function signTransaction(tx) {
+    const wallet = await resolveWallet();
+    return wallet.signTransaction(tx);
+}
+export async function signMessage(message) {
+    const wallet = await resolveWallet();
+    return wallet.signMessage(message);
+}
+export async function signTypedData(domain, types, value) {
+    const wallet = await resolveWallet();
+    return wallet.signTypedData(domain, types, value);
+}
+/**
+ * Send a raw transaction via the wallet's connected provider.
+ * Returns the transaction hash.
+ */
+export async function sendTransaction(tx) {
+    const wallet = await resolveWallet();
+    const populated = await wallet.populateTransaction(tx);
+    const signed = await wallet.signTransaction(populated);
+    const provider = wallet.provider;
+    return provider.send("eth_sendRawTransaction", [signed]);
+}
+/**
+ * Returns the native balance of the configured wallet in human-readable Ether.
+ */
+export async function getWalletBalance() {
+    if (!isWalletConfigured())
+        return "0";
+    const wallet = await resolveWallet();
+    const balance = await wallet.provider.getBalance(wallet.address);
+    // Convert BigInt Wei to a decimal string (Ether)
+    const balanceStr = balance.toString();
+    if (balanceStr === "0")
+        return "0";
+    // Simple formatting: insert decimal 18 places from the right
+    const padded = balanceStr.padStart(19, '0');
+    const integerPart = padded.slice(0, -18);
+    const fractionalPart = padded.slice(-18).replace(/0+$/, '');
+    return fractionalPart ? `${integerPart}.${fractionalPart}` : integerPart;
+}
+/**
+ * Returns a summary of wallet balances for the planner.
+ */
+export async function getWalletBalances() {
+    if (!isWalletConfigured())
+        return {};
+    const balance = await getWalletBalance();
+    return {
+        native: `${balance} ETH`,
+    };
+}