openclaw-overlay-plugin 0.7.33 → 0.7.35

package/index.ts

@@ -52,7 +52,7 @@ function loadDailySpending(walletDir: string): DailySpending {
 }
 
 function writeActivityEvent(event: any) {
-  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');
@@ -106,41 +106,41 @@ async function startAutoImport(env: any, cliPath: string, logger: any) {
           if (knownTxids.has(key)) 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: any) {
-                logger?.warn?.('[bsv-overlay] Auto-registration failed:', err.message);
+                logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
               }
             }
           } catch (err) {
@@ -153,7 +153,7 @@ async function startAutoImport(env: any, cliPath: string, logger: any) {
       }
     }, 30000); // Check every 30 seconds for faster onboarding
   } catch (err: any) {
-    logger?.warn?.('[bsv-overlay] Auto-import setup failed:', err.message);
+    logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
   }
 }
 
@@ -179,7 +179,7 @@ async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
       if (!fs.existsSync(configPath)) 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;
@@ -188,11 +188,11 @@ async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
     }
     
     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: string[] = [];
     const failed: string[] = [];
@@ -214,11 +214,11 @@ async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
       }
     }
     
-    if (advertised.length > 0) logger?.info?.(`[bsv-overlay] Successfully advertised: ${advertised.join(', ')}`);
-    if (failed.length > 0) logger?.warn?.(`[bsv-overlay] Failed to advertise: ${failed.join(', ')}`);
+    if (advertised.length > 0) logger?.info?.(`[openclaw-overlay] Successfully advertised: ${advertised.join(', ')}`);
+    if (failed.length > 0) logger?.warn?.(`[openclaw-overlay] Failed to advertise: ${failed.join(', ')}`);
     
   } catch (err: any) {
-    logger?.warn?.('[bsv-overlay] Auto-advertising failed:', err.message);
+    logger?.warn?.('[openclaw-overlay] Auto-advertising failed:', err.message);
   }
 }
 
@@ -227,12 +227,12 @@ async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
  * This is the standard way to invoke an agent with a specific context.
  */
 function wakeAgent(text: string, logger: any, options: { sessionKey?: string } = {}) {
-  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;
   }
 
@@ -251,14 +251,14 @@ function wakeAgent(text: string, logger: any, options: { sessionKey?: string } =
   })
     .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: any) => {
-      logger?.warn?.('[bsv-overlay] /hooks/agent error:', err.message);
+      logger?.warn?.('[openclaw-overlay] /hooks/agent error:', err.message);
     });
 }
 
@@ -323,15 +323,15 @@ function startBackgroundService(env: any, cliPath: string, logger: any) {
   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: any) {
-        logger?.warn?.('[bsv-overlay] Queue cleanup failed:', err.message);
+        logger?.warn?.('[openclaw-overlay] Queue cleanup failed:', err.message);
       }
     }
   }, 5 * 60 * 1000);
@@ -351,9 +351,9 @@ function startBackgroundService(env: any, cliPath: string, logger: any) {
       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));
+          logger?.debug?.(`[openclaw-overlay] ${event.event || event.type || 'message'}:`, JSON.stringify(event).slice(0, 200));
           
-          const alertDir = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay');
+          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
@@ -363,20 +363,20 @@ function startBackgroundService(env: any, cliPath: string, logger: any) {
 
             // 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
@@ -388,9 +388,9 @@ function startBackgroundService(env: any, cliPath: string, logger: any) {
             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
@@ -410,12 +410,12 @@ function startBackgroundService(env: any, cliPath: string, logger: any) {
         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}`);
         }
       }
     });
@@ -423,7 +423,7 @@ function startBackgroundService(env: any, cliPath: string, logger: any) {
     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);
       }
     });
@@ -448,8 +448,15 @@ function stopBackgroundService() {
 }
 
 export default function register(api: any) {
-  // 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
@@ -585,7 +592,7 @@ export default function register(api: any) {
 
   // 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...");
@@ -615,7 +622,7 @@ export default function register(api: any) {
 
   // Register a skill-style wake handler
   api.registerHook({
-    id: "bsv-overlay-wake",
+    id: "openclaw-overlay-wake",
     event: "gateway:start",
     handler: async (ctx: any) => {
       // Auto-check for registration on startup
@@ -624,8 +631,8 @@ export default function register(api: any) {
           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
@@ -647,7 +654,7 @@ export default function register(api: any) {
                 // 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);
                 }
               }
@@ -655,7 +662,7 @@ export default function register(api: any) {
           }
 
         } catch (err: any) {
-          api.log?.debug?.('[bsv-overlay] Auto-setup/onboarding skipped:', err.message);
+          api.log?.debug?.('[openclaw-overlay] Auto-setup/onboarding skipped:', err.message);
         }
       })();
     }
@@ -721,14 +728,16 @@ export default function register(api: any) {
           if (result.agents) {
             console.log("\nAgents:");
             result.agents.forEach((agent: any) => {
-              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: any) => {
-              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)}`);
             });
           }
         } catch (error: any) {
@@ -981,7 +990,7 @@ async function handleUnregister(params: any, env: any, cliPath: string) {
   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: any = null;
   try {
     if (fs.existsSync(regPath)) {
@@ -1148,29 +1157,51 @@ async function handleDiscover(params: any, env: any, cliPath: string) {
 }
 
 async function handleBalance(env: any, cliPath: string) {
-  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: any) {
+    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: any, cliPath: string) {
   try {
     // Get identity
-    const identityResult = await execFileAsync('node', [cliPath, 'identity'], { env });
-    const identity = parseCliOutput(identityResult.stdout);
+    let identity: any = { data: { identityKey: 'Not Initialized' } };
+    try {
+      const identityResult = await execFileAsync('node', [cliPath, 'identity'], { env });
+      identity = parseCliOutput(identityResult.stdout);
+    } catch (err: any) {
+      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: any = { data: { walletBalance: 0 } };
+    try {
+      const balanceResult = await execFileAsync('node', [cliPath, 'balance'], { env });
+      balance = parseCliOutput(balanceResult.stdout);
+    } catch (err: any) {
+      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: any = { data: [] };
+    try {
+      const servicesResult = await execFileAsync('node', [cliPath, 'services'], { env });
+      services = parseCliOutput(servicesResult.stdout);
+    } catch (err: any) {
+      if (!err.message?.includes('Wallet not initialized')) throw err;
+    }
     
     return {
       identity: identity.data,
@@ -1259,7 +1290,7 @@ async function handleImport(params: any, env: any, cliPath: string) {
   }
 
   // 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) {
@@ -1515,14 +1546,14 @@ async function handlePendingRequests(env: any, cliPath: string) {
   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); } catch {}
 
   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);
@@ -1568,9 +1599,18 @@ function buildEnvironment(config: any) {
   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;
   } else if (!env.AGENT_NAME) {

package/openclaw.plugin.json

@@ -15,11 +15,22 @@
         "default": "https://clawoverlay.com",
         "description": "Overlay server URL for registration, discovery, and relay"
       },
+      "network": {
+        "type": "string",
+        "enum": ["mainnet", "testnet"],
+        "default": "mainnet",
+        "description": "BSV network to use"
+      },
       "chaintracksUrl": {
         "type": "string",
         "default": "https://chaintracks-us-1.bsvb.tech",
         "description": "Custom Chaintracks server URL for SPV header verification"
       },
+      "arcUrl": {
+        "type": "string",
+        "default": "https://arc.gorillapool.io",
+        "description": "Custom ARC/Arcade server URL for transaction broadcasting"
+      },
       "agentName": {
         "type": "string",
         "description": "Display name for this agent on the overlay network (defaults to hostname)"
@@ -69,12 +80,21 @@
       "placeholder": "https://clawoverlay.com",
       "advanced": true
     },
+    "network": {
+      "label": "BSV Network"
+    },
     "chaintracksUrl": {
       "label": "Chaintracks Server URL",
       "placeholder": "https://chaintracks-us-1.bsvb.tech",
       "help": "Custom server for SPV block header verification",
       "advanced": true
     },
+    "arcUrl": {
+      "label": "ARC/Arcade Server URL",
+      "placeholder": "https://arc.gorillapool.io",
+      "help": "Custom server for transaction broadcasting",
+      "advanced": true
+    },
     "agentName": {
       "label": "Agent Name",
       "placeholder": "my-agent",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-overlay-plugin",
-  "version": "0.7.33",
+  "version": "0.7.35",
   "description": "Openclaw BSV Overlay — agent discovery, service marketplace, and micropayments on the BSV blockchain",
   "publishConfig": {
     "access": "public"

package/src/core/wallet.ts

@@ -232,7 +232,13 @@ 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);
 

package/src/scripts/baemail/commands.ts

@@ -288,12 +288,23 @@ export async function cmdBaemailRefund(requestId: string | undefined): Promise<n
 
     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();

package/src/scripts/config.ts

@@ -7,7 +7,7 @@ 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')) {
@@ -43,10 +43,10 @@ export const AGENT_DESCRIPTION = process.env.AGENT_DESCRIPTION ||
 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 = {

package/src/scripts/overlay/discover.ts

@@ -38,7 +38,9 @@ export async function cmdDiscover(args: string[]): Promise<never> {
           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 */ }
         }

package/dist/cli-main.d.ts

@@ -1,7 +0,0 @@
-/**
- * BSV Overlay CLI - Main Command Dispatcher
- *
- * Routes commands to the appropriate modules.
- * All business logic is in the scripts/ modules.
- */
-export {};