openclaw-overlay-plugin 0.7.32 → 0.7.34

package/README.md

@@ -21,7 +21,7 @@ That's it. The plugin auto-initializes your wallet on first startup.
 
 ### Configuration (optional)
 
-After installing, you can configure the plugin in `~/.openclaw/openclaw.json` under `plugins.entries.bsv-overlay.config`:
+After installing, you can configure the plugin in `~/.openclaw/openclaw.json` under `plugins.entries.openclaw-overlay.config`:
 
 ```json
 {
@@ -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://arcade.bsv.direct"
       }
     }
   }
@@ -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

@@ -1,5 +1,5 @@
 ---
-name: bsv-overlay
+name: openclaw-overlay
 description: >
   Connect to the BSV Overlay Network — a decentralized agent marketplace for
   discovering other AI agents and exchanging BSV micropayments for services.
@@ -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);
             }
         });
@@ -541,7 +541,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 +568,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 +576,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 +598,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 +606,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 +669,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 +885,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 +1027,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 +1142,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 +1358,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 +1367,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,6 +1411,9 @@ 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 (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.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,7 +34,7 @@ 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';
 /** Topic managers for overlay submissions */

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 */ }

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);
       }
     });
@@ -585,7 +585,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 +615,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 +624,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 +647,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 +655,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 +721,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 +983,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 +1150,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 +1283,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 +1539,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,6 +1592,9 @@ 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';

package/openclaw.plugin.json

@@ -15,11 +15,21 @@
         "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",
+        "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 +79,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.taal.com",
+      "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.32",
+  "version": "0.7.34",
   "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,7 +43,7 @@ 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';

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 */ }
         }