openclaw-overlay-plugin 0.7.33 → 0.7.35

package/README.md

@@ -33,7 +33,8 @@ After installing, you can configure the plugin in `~/.openclaw/openclaw.json` un
         "agentDescription": "My agent on the overlay network",
         "maxAutoPaySats": 200,
         "dailyBudgetSats": 5000,
-        "chaintracksUrl": "https://chaintracks-us-1.bsvb.tech"
+        "chaintracksUrl": "https://chaintracks-us-1.bsvb.tech",
+        "arcUrl": "https://arc.gorillapool.io"
       }
     }
   }
@@ -49,6 +50,7 @@ After installing, you can configure the plugin in `~/.openclaw/openclaw.json` un
 | `walletDir` | `~/.openclaw/bsv-wallet` | Wallet storage directory |
 | `overlayUrl` | `https://clawoverlay.com` | Overlay network server |
 | `chaintracksUrl` | `https://chaintracks-us-1.bsvb.tech` | Custom SPV header server |
+| `arcUrl` | (uses public ARC) | Custom ARC/Arcade server for broadcasting |
 
 ### Required: Enable Hooks
 

package/SKILL.md

@@ -45,6 +45,20 @@ On first run, the plugin auto-creates a wallet and wakes you. Guide the user thr
 5. **Ask which services to offer**: Present the list from the onboard response, let user pick
 6. **Advertise selected**: `overlay({ action: "advertise", ... })` for each
 
+If you need to customize settings, tell the user to add them to their config under `plugins.entries["openclaw-overlay"]`:
+```json
+{
+  "plugins": {
+    "entries": {
+      "openclaw-overlay": {
+        "agentName": "...",
+        "overlayUrl": "..."
+      }
+    }
+  }
+}
+```
+
 Do NOT use defaults without asking. Do NOT skip the name/description questions.
 
 ## Requesting Services

package/dist/index.js

@@ -38,7 +38,7 @@ function loadDailySpending(walletDir) {
     return { date: today, totalSats: 0, transactions: [] };
 }
 function writeActivityEvent(event) {
-    const alertDir = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay');
+    const alertDir = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay');
     try {
         fs.mkdirSync(alertDir, { recursive: true });
         fs.appendFileSync(path.join(alertDir, 'activity-feed.jsonl'), JSON.stringify({ ...event, ts: Date.now() }) + '\n');
@@ -91,39 +91,39 @@ async function startAutoImport(env, cliPath, logger) {
                         continue;
                     if (utxo.value < 200)
                         continue; // skip dust
-                    logger?.info?.(`[bsv-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
+                    logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
                     try {
                         const importResult = await execFileAsync('node', [cliPath, 'import', utxo.tx_hash, String(utxo.tx_pos)], { env });
                         const importOutput = parseCliOutput(importResult.stdout);
                         if (importOutput.success) {
                             knownTxids.add(key);
-                            logger?.info?.(`[bsv-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
+                            logger?.info?.(`[openclaw-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
                             // Clear onboarding flag since wallet is now funded
                             try {
-                                const onboardingSentFile = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'onboarding-sent.flag');
+                                const onboardingSentFile = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'onboarding-sent.flag');
                                 if (fs.existsSync(onboardingSentFile)) {
                                     fs.unlinkSync(onboardingSentFile);
                                 }
                             }
                             catch { }
                             // Notify agent of successful import
-                            wakeAgent(`💰 **Wallet Funded!**\n\nAuto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...\n\nNotify the user their wallet has been funded.`, logger, { sessionKey: 'hook:bsv-overlay:import' });
+                            wakeAgent(`💰 **Wallet Funded!**\n\nAuto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...\n\nNotify the user their wallet has been funded.`, logger, { sessionKey: 'hook:openclaw-overlay:import' });
                             // Check if registered, auto-register if not
                             try {
-                                const regPath = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'registration.json');
+                                const regPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
                                 if (!fs.existsSync(regPath)) {
-                                    logger?.info?.('[bsv-overlay] Not yet registered — auto-registering...');
+                                    logger?.info?.('[openclaw-overlay] Not yet registered — auto-registering...');
                                     const regResult = await execFileAsync('node', [cliPath, 'register'], { env, timeout: 60000 });
                                     const regOutput = parseCliOutput(regResult.stdout);
                                     if (regOutput.success) {
-                                        logger?.info?.('[bsv-overlay] Auto-registered on overlay network!');
+                                        logger?.info?.('[openclaw-overlay] Auto-registered on overlay network!');
                                         // Auto-advertise services from config
                                         await autoAdvertiseServices(env, cliPath, logger);
                                     }
                                 }
                             }
                             catch (err) {
-                                logger?.warn?.('[bsv-overlay] Auto-registration failed:', err.message);
+                                logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
                             }
                         }
                     }
@@ -139,7 +139,7 @@ async function startAutoImport(env, cliPath, logger) {
         }, 30000); // Check every 30 seconds for faster onboarding
     }
     catch (err) {
-        logger?.warn?.('[bsv-overlay] Auto-import setup failed:', err.message);
+        logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
     }
 }
 function stopAutoImport() {
@@ -162,7 +162,7 @@ async function autoAdvertiseServices(env, cliPath, logger) {
                 continue;
             try {
                 const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-                const pluginConfig = config?.plugins?.entries?.['bsv-overlay']?.config;
+                const pluginConfig = config?.plugins?.entries?.['openclaw-overlay']?.config;
                 if (pluginConfig?.services && Array.isArray(pluginConfig.services)) {
                     servicesToAdvertise = pluginConfig.services;
                     break;
@@ -171,10 +171,10 @@ async function autoAdvertiseServices(env, cliPath, logger) {
             catch { }
         }
         if (servicesToAdvertise.length === 0) {
-            logger?.info?.('[bsv-overlay] No services configured for auto-advertising');
+            logger?.info?.('[openclaw-overlay] No services configured for auto-advertising');
             return;
         }
-        logger?.info?.(`[bsv-overlay] Auto-advertising ${servicesToAdvertise.length} services from config...`);
+        logger?.info?.(`[openclaw-overlay] Auto-advertising ${servicesToAdvertise.length} services from config...`);
         const advertised = [];
         const failed = [];
         for (const serviceId of servicesToAdvertise) {
@@ -194,12 +194,12 @@ async function autoAdvertiseServices(env, cliPath, logger) {
             }
         }
         if (advertised.length > 0)
-            logger?.info?.(`[bsv-overlay] Successfully advertised: ${advertised.join(', ')}`);
+            logger?.info?.(`[openclaw-overlay] Successfully advertised: ${advertised.join(', ')}`);
         if (failed.length > 0)
-            logger?.warn?.(`[bsv-overlay] Failed to advertise: ${failed.join(', ')}`);
+            logger?.warn?.(`[openclaw-overlay] Failed to advertise: ${failed.join(', ')}`);
     }
     catch (err) {
-        logger?.warn?.('[bsv-overlay] Auto-advertising failed:', err.message);
+        logger?.warn?.('[openclaw-overlay] Auto-advertising failed:', err.message);
     }
 }
 /**
@@ -207,11 +207,11 @@ async function autoAdvertiseServices(env, cliPath, logger) {
  * This is the standard way to invoke an agent with a specific context.
  */
 function wakeAgent(text, logger, options = {}) {
-    const sessionKey = options.sessionKey || `hook:bsv-overlay:${Date.now()}`;
+    const sessionKey = options.sessionKey || `hook:openclaw-overlay:${Date.now()}`;
     const gatewayPort = getGatewayPort();
     const httpToken = getHooksToken();
     if (!httpToken) {
-        logger?.warn?.('[bsv-overlay] Skipped wakeAgent: OPENCLAW_HOOKS_TOKEN not set');
+        logger?.warn?.('[openclaw-overlay] Skipped wakeAgent: OPENCLAW_HOOKS_TOKEN not set');
         return;
     }
     const url = `http://localhost:${gatewayPort}/hooks/agent`;
@@ -228,15 +228,15 @@ function wakeAgent(text, logger, options = {}) {
     })
         .then(async (res) => {
         if (res.ok) {
-            logger?.info?.(`[bsv-overlay] Agent invoked via /hooks/agent (session: ${sessionKey})`);
+            logger?.info?.(`[openclaw-overlay] Agent invoked via /hooks/agent (session: ${sessionKey})`);
         }
         else {
             const body = await res.text().catch(() => '');
-            logger?.warn?.(`[bsv-overlay] /hooks/agent failed: ${res.status} ${body}`);
+            logger?.warn?.(`[openclaw-overlay] /hooks/agent failed: ${res.status} ${body}`);
         }
     })
         .catch((err) => {
-        logger?.warn?.('[bsv-overlay] /hooks/agent error:', err.message);
+        logger?.warn?.('[openclaw-overlay] /hooks/agent error:', err.message);
     });
 }
 function getGatewayPort() {
@@ -292,15 +292,15 @@ function startBackgroundService(env, cliPath, logger) {
     requestCleanupInterval = setInterval(async () => {
         if (serviceRunning) {
             wokenRequests.clear();
-            logger?.debug?.('[bsv-overlay] Cleared stale request IDs');
+            logger?.debug?.('[openclaw-overlay] Cleared stale request IDs');
             // Also clean up old queue entries
             try {
                 const { cleanupServiceQueue } = await import('./src/scripts/utils/storage.js');
                 cleanupServiceQueue();
-                logger?.debug?.('[bsv-overlay] Cleaned up old queue entries');
+                logger?.debug?.('[openclaw-overlay] Cleaned up old queue entries');
             }
             catch (err) {
-                logger?.warn?.('[bsv-overlay] Queue cleanup failed:', err.message);
+                logger?.warn?.('[openclaw-overlay] Queue cleanup failed:', err.message);
             }
         }
     }, 5 * 60 * 1000);
@@ -317,8 +317,8 @@ function startBackgroundService(env, cliPath, logger) {
             for (const line of lines) {
                 try {
                     const event = JSON.parse(line);
-                    logger?.debug?.(`[bsv-overlay] ${event.event || event.type || 'message'}:`, JSON.stringify(event).slice(0, 200));
-                    const alertDir = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay');
+                    logger?.debug?.(`[openclaw-overlay] ${event.event || event.type || 'message'}:`, JSON.stringify(event).slice(0, 200));
+                    const alertDir = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay');
                     fs.mkdirSync(alertDir, { recursive: true });
                     // Detect queued-for-agent events — invoke agent via /hooks/agent
                     // This is the PROVIDER side: someone requested our service
@@ -326,18 +326,18 @@ function startBackgroundService(env, cliPath, logger) {
                         const requestId = event.id || `${event.from}-${Date.now()}`;
                         // Check if already woken to prevent duplicate processing
                         if (wokenRequests.has(requestId)) {
-                            logger?.debug?.(`[bsv-overlay] Request ${requestId} already woken, skipping duplicate`);
+                            logger?.debug?.(`[openclaw-overlay] Request ${requestId} already woken, skipping duplicate`);
                             return;
                         }
                         // Skip wake-up for already processed requests unless they're pending
                         if (event.action?.startsWith('already-') && !event.action.includes('pending')) {
-                            logger?.debug?.(`[bsv-overlay] Request ${requestId} already processed (${event.action}), skipping`);
+                            logger?.debug?.(`[openclaw-overlay] Request ${requestId} already processed (${event.action}), skipping`);
                             return;
                         }
                         wokenRequests.add(requestId);
-                        logger?.info?.(`[bsv-overlay] ⚡ Incoming ${event.serviceId} request from ${event.from?.slice(0, 12)}...`);
+                        logger?.info?.(`[openclaw-overlay] ⚡ Incoming ${event.serviceId} request from ${event.from?.slice(0, 12)}...`);
                         const wakeText = `⚡ Incoming overlay service request!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nPaid: ${event.satoshisReceived || '?'} sats\n\nFulfill it now:\n1. overlay({ action: "pending-requests" })\n2. Process the ${event.serviceId} request using your capabilities\n3. overlay({ action: "fulfill", requestId: "${event.id}", recipientKey: "${event.from}", serviceId: "${event.serviceId}", result: { ... } })`;
-                        wakeAgent(wakeText, logger, { sessionKey: `hook:bsv-overlay:${event.id || Date.now()}` });
+                        wakeAgent(wakeText, logger, { sessionKey: `hook:openclaw-overlay:${event.id || Date.now()}` });
                     }
                     // Detect service-response events — invoke agent to notify user
                     // This is the REQUESTER side: we requested a service, response came back
@@ -347,9 +347,9 @@ function startBackgroundService(env, cliPath, logger) {
                         const from = event.from || 'unknown';
                         const formatted = event.formatted || '';
                         const resultJson = event.result ? JSON.stringify(event.result, null, 2) : '(no result data)';
-                        logger?.info?.(`[bsv-overlay] 📬 Response received for ${svcId} from ${from?.slice(0, 12)}... — status: ${status}`);
+                        logger?.info?.(`[openclaw-overlay] 📬 Response received for ${svcId} from ${from?.slice(0, 12)}... — status: ${status}`);
                         const wakeText = `📬 Overlay service response received!\n\nService: ${svcId}\nFrom: ${from}\nStatus: ${status}\n${formatted ? `\nSummary: ${formatted}` : ''}\n\nFull result:\n${resultJson}\n\nNotify the user of this response in a clear, human-readable format.`;
-                        wakeAgent(wakeText, logger, { sessionKey: `hook:bsv-overlay:resp-${event.requestId || Date.now()}` });
+                        wakeAgent(wakeText, logger, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
                     }
                     // Write payment/activity notifications for ALL significant events
                     const notifEvent = categorizeEvent(event);
@@ -369,21 +369,21 @@ function startBackgroundService(env, cliPath, logger) {
                 try {
                     const event = JSON.parse(line);
                     if (event.event === 'connected') {
-                        logger?.info?.('[bsv-overlay] WebSocket relay connected');
+                        logger?.info?.('[openclaw-overlay] WebSocket relay connected');
                     }
                     else if (event.event === 'disconnected') {
-                        logger?.warn?.('[bsv-overlay] WebSocket disconnected, reconnecting...');
+                        logger?.warn?.('[openclaw-overlay] WebSocket disconnected, reconnecting...');
                     }
                 }
                 catch {
-                    logger?.debug?.(`[bsv-overlay] ${line}`);
+                    logger?.debug?.(`[openclaw-overlay] ${line}`);
                 }
             }
         });
         proc.on('exit', (code) => {
             backgroundProcess = null;
             if (serviceRunning) {
-                logger?.warn?.(`[bsv-overlay] Background service exited (code ${code}), restarting in 5s...`);
+                logger?.warn?.(`[openclaw-overlay] Background service exited (code ${code}), restarting in 5s...`);
                 setTimeout(spawnConnect, 5000);
             }
         });
@@ -405,8 +405,14 @@ function stopBackgroundService() {
     stopAutoImport();
 }
 export default function register(api) {
-    // Capture config at registration time (handle both flat and nested structures)
-    const entry = api.getConfig?.()?.plugins?.entries?.['openclaw-overlay'] || {};
+    // Capture config at registration time
+    // Check all possible IDs for backward compatibility and various installation methods
+    const entries = api.getConfig?.()?.plugins?.entries || {};
+    const entry = entries['openclaw-overlay']
+        || entries['openclaw-overlay-plugin']
+        || entries['bsv-overlay']
+        || {};
+    // Merge: gateway-level api.config > nested entry.config > flat entry properties
     const pluginConfig = { ...entry, ...(entry.config || {}), ...(api.config || {}) };
     // Register the overlay agent tool
     api.registerTool({
@@ -541,7 +547,7 @@ export default function register(api) {
     });
     // Register background relay service
     api.registerService({
-        id: "bsv-overlay-relay",
+        id: "openclaw-overlay-relay",
         start: async () => {
             try {
                 api.logger.info("Starting BSV overlay WebSocket relay...");
@@ -568,7 +574,7 @@ export default function register(api) {
     });
     // Register a skill-style wake handler
     api.registerHook({
-        id: "bsv-overlay-wake",
+        id: "openclaw-overlay-wake",
         event: "gateway:start",
         handler: async (ctx) => {
             // Auto-check for registration on startup
@@ -576,8 +582,8 @@ export default function register(api) {
                 try {
                     const env = buildEnvironment(pluginConfig);
                     const cliPath = path.join(__dirname, 'dist', 'cli.js');
-                    const regPath = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'registration.json');
-                    const onboardSentFile = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'onboarding-sent.flag');
+                    const regPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
+                    const onboardSentFile = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'onboarding-sent.flag');
                     if (!fs.existsSync(regPath) && !fs.existsSync(onboardSentFile)) {
                         // Check if wallet exists
                         const walletPath = path.join(pluginConfig.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet'), 'wallet-identity.json');
@@ -598,7 +604,7 @@ export default function register(api) {
                                 // Funded but not registered. Auto-register.
                                 const regResult = await execFileAsync('node', [cliPath, 'register'], { env, timeout: 60000 });
                                 if (parseCliOutput(regResult.stdout).success) {
-                                    ctx.logger.info('[bsv-overlay] Agent auto-registered on startup');
+                                    ctx.logger.info('[openclaw-overlay] Agent auto-registered on startup');
                                     await autoAdvertiseServices(env, cliPath, ctx.logger);
                                 }
                             }
@@ -606,7 +612,7 @@ export default function register(api) {
                     }
                 }
                 catch (err) {
-                    api.log?.debug?.('[bsv-overlay] Auto-setup/onboarding skipped:', err.message);
+                    api.log?.debug?.('[openclaw-overlay] Auto-setup/onboarding skipped:', err.message);
                 }
             })();
         }
@@ -669,13 +675,15 @@ export default function register(api) {
                 if (result.agents) {
                     console.log("\nAgents:");
                     result.agents.forEach((agent) => {
-                        console.log(`- ${agent.name} (${agent.identityKey.slice(0, 16)}...)`);
+                        const name = agent.name || agent.agentName || 'Unknown Agent';
+                        console.log(`- ${name} (${agent.identityKey.slice(0, 16)}...)`);
                     });
                 }
                 if (result.services) {
                     console.log("\nServices:");
                     result.services.forEach((service) => {
-                        console.log(`- ${service.name} (${service.serviceId}): ${service.pricing?.amountSats || 0} sats [${service.identityKey.slice(0, 12)}]`);
+                        const name = service.name || service.agentName || 'Unknown Agent';
+                        console.log(`- ${service.serviceId} - ${name} (${service.pricing?.amountSats || 0} sats) by ${service.identityKey.slice(0, 12)}`);
                     });
                 }
             }
@@ -883,7 +891,7 @@ function validateConfirmToken(token, expectedAction) {
 async function handleUnregister(params, env, cliPath) {
     const { confirmToken } = params;
     // Load current registration to show what will be deleted
-    const regPath = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'registration.json');
+    const regPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
     let registration = null;
     try {
         if (fs.existsSync(regPath)) {
@@ -1025,24 +1033,53 @@ async function handleDiscover(params, env, cliPath) {
     return output.data;
 }
 async function handleBalance(env, cliPath) {
-    const result = await execFileAsync('node', [cliPath, 'balance'], { env });
-    const output = parseCliOutput(result.stdout);
-    if (!output.success) {
-        throw new Error(`Balance check failed: ${output.error}`);
+    try {
+        const result = await execFileAsync('node', [cliPath, 'balance'], { env });
+        const output = parseCliOutput(result.stdout);
+        if (!output.success) {
+            throw new Error(output.error);
+        }
+        return output.data;
+    }
+    catch (error) {
+        if (error.message?.includes('Wallet not initialized')) {
+            return { walletBalance: 0, error: 'Not Initialized' };
+        }
+        throw new Error(`Balance check failed: ${error.message}`);
     }
-    return output.data;
 }
 async function handleStatus(env, cliPath) {
     try {
         // Get identity
-        const identityResult = await execFileAsync('node', [cliPath, 'identity'], { env });
-        const identity = parseCliOutput(identityResult.stdout);
+        let identity = { data: { identityKey: 'Not Initialized' } };
+        try {
+            const identityResult = await execFileAsync('node', [cliPath, 'identity'], { env });
+            identity = parseCliOutput(identityResult.stdout);
+        }
+        catch (err) {
+            if (!err.message?.includes('Wallet not initialized'))
+                throw err;
+        }
         // Get balance
-        const balanceResult = await execFileAsync('node', [cliPath, 'balance'], { env });
-        const balance = parseCliOutput(balanceResult.stdout);
+        let balance = { data: { walletBalance: 0 } };
+        try {
+            const balanceResult = await execFileAsync('node', [cliPath, 'balance'], { env });
+            balance = parseCliOutput(balanceResult.stdout);
+        }
+        catch (err) {
+            if (!err.message?.includes('Wallet not initialized'))
+                throw err;
+        }
         // Get services
-        const servicesResult = await execFileAsync('node', [cliPath, 'services'], { env });
-        const services = parseCliOutput(servicesResult.stdout);
+        let services = { data: [] };
+        try {
+            const servicesResult = await execFileAsync('node', [cliPath, 'services'], { env });
+            services = parseCliOutput(servicesResult.stdout);
+        }
+        catch (err) {
+            if (!err.message?.includes('Wallet not initialized'))
+                throw err;
+        }
         return {
             identity: identity.data,
             balance: balance.data,
@@ -1111,7 +1148,7 @@ async function handleImport(params, env, cliPath) {
         throw new Error(`Import failed: ${output.error}`);
     }
     // Check if we should auto-register after successful import
-    const regPath = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'registration.json');
+    const regPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
     const isRegistered = fs.existsSync(regPath);
     if (!isRegistered && output.data?.balance >= 1000) {
         // Auto-register immediately after funding
@@ -1327,7 +1364,7 @@ async function handlePendingRequests(env, cliPath) {
     if (!output.success)
         throw new Error(`Queue check failed: ${output.error}`);
     // Clear the alert file since we're checking now
-    const alertPath = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'pending-alert.jsonl');
+    const alertPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'pending-alert.jsonl');
     try {
         if (fs.existsSync(alertPath))
             fs.unlinkSync(alertPath);
@@ -1336,7 +1373,7 @@ async function handlePendingRequests(env, cliPath) {
     return output.data;
 }
 function handleActivity() {
-    const feedPath = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'activity-feed.jsonl');
+    const feedPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'activity-feed.jsonl');
     if (!fs.existsSync(feedPath))
         return { events: [], count: 0 };
     const lines = fs.readFileSync(feedPath, 'utf-8').trim().split('\n').filter(Boolean);
@@ -1380,8 +1417,16 @@ function buildEnvironment(config) {
     if (config.chaintracksUrl) {
         env.BSV_CHAINTRACKS_URL = config.chaintracksUrl;
     }
+    if (config.arcUrl) {
+        env.BSV_ARC_URL = config.arcUrl;
+    }
     // Set defaults
     env.BSV_NETWORK = env.BSV_NETWORK || 'mainnet';
+    if (!env.BSV_ARC_URL) {
+        env.BSV_ARC_URL = env.BSV_NETWORK === 'testnet'
+            ? 'https://testnet.arc.gorillapool.io'
+            : 'https://arc.gorillapool.io';
+    }
     if (config.agentName) {
         env.AGENT_NAME = config.agentName;
     }

package/dist/src/core/wallet.js

@@ -176,7 +176,11 @@ export class BSVAgentWallet {
         // 3. Network services (ARC broadcasting, chain tracking, etc.)
         const serviceOptions = Services.createDefaultOptions(chain);
         const chaintracksUrl = process.env.BSV_CHAINTRACKS_URL || 'https://chaintracks-us-1.bsvb.tech';
+        const arcUrl = process.env.BSV_ARC_URL;
         serviceOptions.chaintracks = new ChaintracksServiceClient(chain, chaintracksUrl);
+        if (arcUrl) {
+            serviceOptions.arcUrl = arcUrl;
+        }
         serviceOptions.taalApiKey = taalApiKey;
         const services = new Services(serviceOptions);
         // 4. Background monitor

package/dist/src/scripts/baemail/commands.js

@@ -224,12 +224,23 @@ export async function cmdBaemailRefund(requestId) {
             });
         }
         await tx.sign();
-        // Broadcast
-        const broadcastResp = await fetchWithTimeout('https://api.whatsonchain.com/v1/bsv/main/tx/raw', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ txhex: tx.toHex() }),
-        });
+        // Broadcast using configured ARC/Arcade URL or fallback to WhatsOnChain
+        const arcUrl = process.env.BSV_ARC_URL;
+        let broadcastResp;
+        if (arcUrl) {
+            broadcastResp = await fetchWithTimeout(`${arcUrl.replace(/\/$/, '')}/v1/tx`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ rawTx: tx.toHex() }),
+            });
+        }
+        else {
+            broadcastResp = await fetchWithTimeout('https://api.whatsonchain.com/v1/bsv/main/tx/raw', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ txhex: tx.toHex() }),
+            });
+        }
         if (!broadcastResp.ok) {
             const errBody = await broadcastResp.text();
             return fail(`Broadcast failed: ${errBody}`);

package/dist/src/scripts/config.d.ts

@@ -16,7 +16,7 @@ export declare const WOC_API_KEY: string;
 /** Overlay state directory for registration, services, etc. */
 export declare const OVERLAY_STATE_DIR: string;
 /** Protocol identifier for overlay transactions */
-export declare const PROTOCOL_ID = "openclaw overlay v1";
+export declare const PROTOCOL_ID = "clawdbot-overlay-v1";
 /** Topic managers for overlay submissions */
 export declare const TOPICS: {
     readonly IDENTITY: "tm_openclaw_identity";

package/dist/src/scripts/config.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import os from 'node:os';
 import fs from 'node:fs';
 // Auto-load .env from overlay state dir if it exists
-const overlayEnvPath = path.join(os.homedir(), '.openclaw', 'bsv-overlay', '.env');
+const overlayEnvPath = path.join(os.homedir(), '.openclaw', 'openclaw-overlay', '.env');
 try {
     if (fs.existsSync(overlayEnvPath)) {
         for (const line of fs.readFileSync(overlayEnvPath, 'utf-8').split('\n')) {
@@ -34,9 +34,9 @@ export const AGENT_DESCRIPTION = process.env.AGENT_DESCRIPTION ||
 /** WhatsOnChain API key (optional, for rate limit bypass) */
 export const WOC_API_KEY = process.env.WOC_API_KEY || '';
 /** Overlay state directory for registration, services, etc. */
-export const OVERLAY_STATE_DIR = path.join(os.homedir(), '.openclaw', 'bsv-overlay');
+export const OVERLAY_STATE_DIR = path.join(os.homedir(), '.openclaw', 'openclaw-overlay');
 /** Protocol identifier for overlay transactions */
-export const PROTOCOL_ID = 'openclaw overlay v1';
+export const PROTOCOL_ID = 'clawdbot-overlay-v1';
 /** Topic managers for overlay submissions */
 export const TOPICS = {
     IDENTITY: 'tm_openclaw_identity',

package/dist/src/scripts/overlay/discover.js

@@ -28,7 +28,9 @@ export async function cmdDiscover(args) {
                     try {
                         const { data, txid } = await parseOverlayOutput(output.beef, output.outputIndex);
                         if (data?.type === 'identity') {
-                            results.agents.push({ ...data, txid });
+                            // Handle both 'name' and 'agentName' for backward compatibility
+                            const name = data.name || data.agentName || 'Unknown Agent';
+                            results.agents.push({ ...data, name, txid });
                         }
                     }
                     catch { /* ignore */ }