openclaw-overlay-plugin 0.7.22

package/dist/scripts/overlay/registration.js

@@ -0,0 +1,176 @@
+/**
+ * Overlay registration commands: register, unregister.
+ *
+ * Registration creates an identity record on the overlay network with:
+ * - identityKey: compressed public key (66 hex chars)
+ * - name: agent display name
+ * - description: what the agent does
+ * - channels: contact methods (e.g., { overlay: "https://..." })
+ * - capabilities: what the agent can do (e.g., ["services", "jokes"])
+ * - timestamp: ISO 8601 registration time
+ */
+import fs from 'node:fs';
+import { NETWORK, WALLET_DIR, OVERLAY_URL, PROTOCOL_ID, TOPICS, PATHS, AGENT_NAME, AGENT_DESCRIPTION } from '../config.js';
+import { ok, fail } from '../output.js';
+import { loadRegistration, saveRegistration, deleteRegistration, loadServices } from '../utils/storage.js';
+import { buildRealOverlayTransaction } from './transaction.js';
+import { Transaction, Beef, Script, PushDrop } from '@bsv/sdk';
+import { BSVAgentWallet } from '../../core/index.js';
+async function getBSVAgentWallet() {
+    return BSVAgentWallet;
+}
+/**
+ * Register command: register this agent on the overlay network.
+ */
+export async function cmdRegister() {
+    if (!fs.existsSync(PATHS.walletIdentity)) {
+        return fail('Wallet not initialized. Run: setup');
+    }
+    const BSVAgentWallet = await getBSVAgentWallet();
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const identityKey = await wallet.getIdentityKey();
+    await wallet.destroy();
+    const existingReg = loadRegistration();
+    if (existingReg && existingReg.identityKey === identityKey) {
+        return ok({
+            alreadyRegistered: true,
+            identityKey,
+            identityTxid: existingReg.identityTxid,
+            overlayUrl: OVERLAY_URL,
+        });
+    }
+    // Agent metadata from environment/config
+    const agentName = AGENT_NAME;
+    const agentDescription = AGENT_DESCRIPTION;
+    // Build capabilities list based on what services we might offer
+    const capabilities = ['services'];
+    const services = loadServices();
+    if (services.some(s => s.serviceId === 'tell-joke')) {
+        capabilities.push('jokes');
+    }
+    // Create identity record on-chain
+    // This payload format matches the clawdbot-overlay server's expected schema
+    const identityPayload = {
+        protocol: PROTOCOL_ID,
+        type: 'identity',
+        identityKey,
+        name: agentName,
+        description: agentDescription,
+        channels: {
+            overlay: OVERLAY_URL,
+        },
+        capabilities,
+        timestamp: new Date().toISOString(),
+    };
+    let identityResult;
+    try {
+        identityResult = await buildRealOverlayTransaction(identityPayload, TOPICS.IDENTITY);
+    }
+    catch (err) {
+        return fail(`Registration failed: ${err.message}`);
+    }
+    // Optionally register services if pre-configured
+    let serviceTxid = null;
+    if (services.length > 0) {
+        // Register each service individually (server expects 'service' type, not 'service-bundle')
+        for (const service of services) {
+            const servicePayload = {
+                protocol: PROTOCOL_ID,
+                type: 'service',
+                identityKey,
+                serviceId: service.serviceId,
+                name: service.name,
+                description: service.description,
+                pricing: {
+                    model: 'per-task',
+                    amountSats: service.priceSats,
+                },
+                timestamp: new Date().toISOString(),
+            };
+            try {
+                const serviceResult = await buildRealOverlayTransaction(servicePayload, TOPICS.SERVICES);
+                serviceTxid = serviceResult.txid; // Keep last one for backward compat
+            }
+            catch {
+                // Non-fatal — identity registered but this service failed
+            }
+        }
+    }
+    // Save registration
+    const registration = {
+        identityKey,
+        agentName,
+        agentDescription,
+        overlayUrl: OVERLAY_URL,
+        identityTxid: identityResult.txid,
+        serviceTxid,
+        funded: identityResult.funded,
+        registeredAt: new Date().toISOString(),
+    };
+    saveRegistration(registration);
+    return ok({
+        registered: true,
+        identityKey,
+        identityTxid: identityResult.txid,
+        serviceTxid,
+        overlayUrl: OVERLAY_URL,
+        funded: identityResult.funded,
+        stateFile: PATHS.registration,
+    });
+}
+/**
+ * Unregister command: submit revocation tx to remove agent from overlay network.
+ */
+export async function cmdUnregister() {
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const { outputs, BEEF } = await wallet._setup.wallet.listOutputs({ basket: TOPICS.IDENTITY, include: 'entire transactions' });
+    const token = new PushDrop(wallet._setup.wallet);
+    const unlockingScriptTemplate = await token.unlock([0, PROTOCOL_ID], '1', 'self', 'none', true);
+    const tempTx = new Transaction();
+    const beef = Beef.fromBinary(BEEF);
+    outputs.forEach((o) => {
+        const [txid, v] = o.outpoint.split('.');
+        const sourceOutputIndex = Number(v);
+        const sourceTransaction = beef.findTransactionForSigning(txid);
+        tempTx.addInput({
+            unlockingScriptTemplate,
+            sourceOutputIndex,
+            sourceTransaction
+        });
+    });
+    tempTx.addOutput({
+        lockingScript: Script.fromASM('OP_FALSE OP_RETURN 330123'),
+        satoshis: 0
+    });
+    await tempTx.sign();
+    const response = await wallet._setup.wallet.createAction({
+        inputBEEF: BEEF,
+        description: 'revoke registration token',
+        inputs: tempTx.inputs.map(o => ({
+            inputDescription: 'previous registration',
+            outpoint: o.sourceTXID + '.' + String(o.sourceOutputIndex),
+            unlockingScript: o.unlockingScript?.toHex()
+        }))
+    });
+    const txid = response.txid;
+    // --- Submit to overlay ---
+    // Use binary BEEF with X-Topics header (matches clawdbot-overlay server API)
+    const submitResp = await fetch(`${OVERLAY_URL}/submit`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/octet-stream',
+            'X-Topics': JSON.stringify([TOPICS.IDENTITY]),
+        },
+        body: new Uint8Array(response.tx),
+    });
+    if (!submitResp.ok) {
+        const errText = await submitResp.text();
+        throw new Error(`Overlay submission failed: ${submitResp.status} — ${errText}`);
+    }
+    // Delete local registration
+    deleteRegistration();
+    return ok({
+        unregistered: true,
+        txid
+    });
+}

package/dist/scripts/overlay/services.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Overlay service commands: services, advertise, remove, readvertise.
+ *
+ * Service payloads match the clawdbot-overlay server schema:
+ * - protocol: "clawdbot-overlay-v1"
+ * - type: "service"
+ * - identityKey: provider's compressed public key
+ * - serviceId: unique service identifier
+ * - name: human-readable name
+ * - description: what the service does
+ * - pricing: { model: "per-task", amountSats: number }
+ * - timestamp: ISO 8601 time
+ */
+/**
+ * Services command: list currently advertised services.
+ */
+export declare function cmdServices(): Promise<never>;
+/**
+ * Advertise command: add a new service advertisement.
+ */
+export declare function cmdAdvertise(serviceId: string | undefined, name: string | undefined, priceSatsStr: string | undefined, description?: string): Promise<never>;
+/**
+ * Remove command: remove a service from local registry.
+ */
+export declare function cmdRemove(serviceId: string | undefined): Promise<never>;
+/**
+ * Readvertise command: update an existing service advertisement.
+ */
+export declare function cmdReadvertise(serviceId: string | undefined, name?: string, priceSatsStr?: string, description?: string): Promise<never>;

package/dist/scripts/overlay/services.js

@@ -0,0 +1,167 @@
+/**
+ * Overlay service commands: services, advertise, remove, readvertise.
+ *
+ * Service payloads match the clawdbot-overlay server schema:
+ * - protocol: "clawdbot-overlay-v1"
+ * - type: "service"
+ * - identityKey: provider's compressed public key
+ * - serviceId: unique service identifier
+ * - name: human-readable name
+ * - description: what the service does
+ * - pricing: { model: "per-task", amountSats: number }
+ * - timestamp: ISO 8601 time
+ */
+import { NETWORK, WALLET_DIR, PROTOCOL_ID, TOPICS } from '../config.js';
+import { ok, fail } from '../output.js';
+import { loadServices, saveServices } from '../utils/storage.js';
+import { buildRealOverlayTransaction } from './transaction.js';
+import { BSVAgentWallet } from '../../core/index.js';
+async function getBSVAgentWallet() {
+    return BSVAgentWallet;
+}
+/**
+ * Services command: list currently advertised services.
+ */
+export async function cmdServices() {
+    const services = loadServices();
+    return ok({ services, count: services.length });
+}
+/**
+ * Advertise command: add a new service advertisement.
+ */
+export async function cmdAdvertise(serviceId, name, priceSatsStr, description) {
+    if (!serviceId || !name || !priceSatsStr) {
+        return fail('Usage: advertise <serviceId> <name> <priceSats> [description]');
+    }
+    const priceSats = parseInt(priceSatsStr, 10);
+    if (isNaN(priceSats) || priceSats < 0) {
+        return fail('priceSats must be a non-negative integer');
+    }
+    const BSVAgentWallet = await getBSVAgentWallet();
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const identityKey = await wallet.getIdentityKey();
+    await wallet.destroy();
+    // Load existing services
+    const services = loadServices();
+    const existing = services.find(s => s.serviceId === serviceId);
+    if (existing) {
+        return fail(`Service '${serviceId}' already exists. Use 'readvertise' to update.`);
+    }
+    // Create service record (local storage format)
+    const newService = {
+        serviceId,
+        name,
+        description: description || `${name} service`,
+        priceSats,
+        registeredAt: new Date().toISOString(),
+    };
+    // Publish on-chain (matches clawdbot-overlay server schema)
+    const servicePayload = {
+        protocol: PROTOCOL_ID,
+        type: 'service',
+        identityKey,
+        serviceId,
+        name,
+        description: newService.description,
+        pricing: {
+            model: 'per-task',
+            amountSats: priceSats,
+        },
+        timestamp: new Date().toISOString(),
+    };
+    try {
+        const result = await buildRealOverlayTransaction(servicePayload, TOPICS.SERVICES);
+        newService.txid = result.txid;
+        // Save locally
+        services.push(newService);
+        saveServices(services);
+        return ok({
+            advertised: true,
+            service: newService,
+            txid: result.txid,
+            funded: result.funded,
+        });
+    }
+    catch (err) {
+        return fail(`Failed to advertise service: ${err.message}`);
+    }
+}
+/**
+ * Remove command: remove a service from local registry.
+ */
+export async function cmdRemove(serviceId) {
+    if (!serviceId) {
+        return fail('Usage: remove <serviceId>');
+    }
+    const services = loadServices();
+    const idx = services.findIndex(s => s.serviceId === serviceId);
+    if (idx === -1) {
+        return fail(`Service '${serviceId}' not found`);
+    }
+    const removed = services.splice(idx, 1)[0];
+    saveServices(services);
+    return ok({
+        removed: true,
+        service: removed,
+        note: 'Removed from local registry. On-chain record remains (blockchain is immutable).',
+    });
+}
+/**
+ * Readvertise command: update an existing service advertisement.
+ */
+export async function cmdReadvertise(serviceId, name, priceSatsStr, description) {
+    if (!serviceId) {
+        return fail('Usage: readvertise <serviceId> [name] [priceSats] [description]');
+    }
+    const services = loadServices();
+    const existing = services.find(s => s.serviceId === serviceId);
+    if (!existing) {
+        return fail(`Service '${serviceId}' not found. Use 'advertise' to create.`);
+    }
+    const BSVAgentWallet = await getBSVAgentWallet();
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const identityKey = await wallet.getIdentityKey();
+    await wallet.destroy();
+    // Update fields if provided
+    if (name)
+        existing.name = name;
+    if (priceSatsStr) {
+        const priceSats = parseInt(priceSatsStr, 10);
+        if (isNaN(priceSats) || priceSats < 0) {
+            return fail('priceSats must be a non-negative integer');
+        }
+        existing.priceSats = priceSats;
+    }
+    if (description)
+        existing.description = description;
+    existing.registeredAt = new Date().toISOString();
+    // Publish update on-chain (matches clawdbot-overlay server schema)
+    const servicePayload = {
+        protocol: PROTOCOL_ID,
+        type: 'service',
+        identityKey,
+        serviceId,
+        name: existing.name,
+        description: existing.description,
+        pricing: {
+            model: 'per-task',
+            amountSats: existing.priceSats,
+        },
+        timestamp: existing.registeredAt,
+    };
+    try {
+        const result = await buildRealOverlayTransaction(servicePayload, TOPICS.SERVICES);
+        existing.txid = result.txid;
+        // Save locally
+        saveServices(services);
+        return ok({
+            readvertised: true,
+            service: existing,
+            txid: result.txid,
+            funded: result.funded,
+        });
+    }
+    catch (err) {
+        return fail(`Failed to readvertise service: ${err.message}`);
+    }
+}

package/dist/scripts/overlay/transaction.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Overlay transaction building utilities.
+ *
+ * Follows the clawdbot-overlay server API:
+ * - Submit: POST /submit with binary BEEF and X-Topics header
+ * - OP_RETURN format: OP_FALSE OP_RETURN <"clawdbot-overlay-v1"> <JSON>
+ */
+import type { OverlayPayload } from '../types.js';
+import { BSVAgentWallet } from '../../core/wallet.js';
+/**
+ * Build an PushDrop locking script with JSON payload using SDK's Script class.
+ *
+ * @param payload - The data to embed in the OP_RETURN
+ * @returns A proper Script object that the SDK can serialize
+ */
+export declare function buildPushDropScript(wallet: BSVAgentWallet, payload: OverlayPayload): Promise<string>;
+/**
+ * Build and submit an overlay transaction.
+ * @param payload - JSON data to store in OP_RETURN
+ * @param topic - Topic manager for submission
+ * @returns Transaction result with txid and funding info
+ */
+export declare function buildRealOverlayTransaction(payload: OverlayPayload, topic: string): Promise<{
+    txid: string;
+    funded: string;
+    explorer: string;
+}>;
+/**
+ * Lookup data from an overlay lookup service.
+ */
+export declare function lookupOverlay(service: string, query: Record<string, unknown>): Promise<any>;
+/**
+ * Parse an overlay output from BEEF data.
+ *
+ * Handles both formats:
+ * - OP_FALSE OP_RETURN <protocol> <json> (standard)
+ * - OP_RETURN <protocol> <json> (legacy)
+ */
+export declare function parseOverlayOutput(beefData: string | Uint8Array | number[], outputIndex: number): Promise<{
+    data: OverlayPayload | null;
+    txid: string | null;
+}>;

package/dist/scripts/overlay/transaction.js

@@ -0,0 +1,103 @@
+/**
+ * Overlay transaction building utilities.
+ *
+ * Follows the clawdbot-overlay server API:
+ * - Submit: POST /submit with binary BEEF and X-Topics header
+ * - OP_RETURN format: OP_FALSE OP_RETURN <"clawdbot-overlay-v1"> <JSON>
+ */
+import { NETWORK, OVERLAY_URL, PROTOCOL_ID, WALLET_DIR } from '../config.js';
+import { Utils, PushDrop, Transaction } from '@bsv/sdk';
+import { BSVAgentWallet } from '../../core/wallet.js';
+/**
+ * Build an PushDrop locking script with JSON payload using SDK's Script class.
+ *
+ * @param payload - The data to embed in the OP_RETURN
+ * @returns A proper Script object that the SDK can serialize
+ */
+export async function buildPushDropScript(wallet, payload) {
+    const jsonBytes = Utils.toArray(JSON.stringify(payload), 'utf8');
+    const fields = [jsonBytes];
+    const token = new PushDrop(wallet._setup.wallet);
+    const script = await token.lock(fields, [0, PROTOCOL_ID], '1', 'self', true, true);
+    return script.toHex();
+}
+/**
+ * Build and submit an overlay transaction.
+ * @param payload - JSON data to store in OP_RETURN
+ * @param topic - Topic manager for submission
+ * @returns Transaction result with txid and funding info
+ */
+export async function buildRealOverlayTransaction(payload, topic) {
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const lockingScript = await buildPushDropScript(wallet, payload);
+    const response = await wallet._setup.wallet.createAction({
+        description: 'topic manager submission',
+        outputs: [
+            {
+                lockingScript,
+                satoshis: 1,
+                outputDescription: 'overlay',
+                basket: topic, // basket is the topic manager
+            }
+        ],
+        options: {
+            acceptDelayedBroadcast: false,
+        }
+    });
+    // --- Submit to overlay ---
+    // Use binary BEEF with X-Topics header (matches clawdbot-overlay server API)
+    const submitResp = await fetch(`${OVERLAY_URL}/submit`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/octet-stream',
+            'X-Topics': JSON.stringify([topic]),
+        },
+        body: new Uint8Array(response.tx),
+    });
+    if (!submitResp.ok) {
+        const errText = await submitResp.text();
+        throw new Error(`Overlay submission failed: ${submitResp.status} — ${errText}`);
+    }
+    const wocNet = NETWORK === 'mainnet' ? '' : 'test.';
+    return {
+        txid: response.txid,
+        funded: 'stored-beef',
+        explorer: `https://${wocNet}whatsonchain.com/tx/${response.txid}`,
+    };
+}
+/**
+ * Lookup data from an overlay lookup service.
+ */
+export async function lookupOverlay(service, query) {
+    const resp = await fetch(`${OVERLAY_URL}/lookup`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ service, query }),
+    });
+    if (!resp.ok) {
+        const errText = await resp.text();
+        throw new Error(`Lookup failed: ${resp.status} — ${errText}`);
+    }
+    return resp.json();
+}
+/**
+ * Parse an overlay output from BEEF data.
+ *
+ * Handles both formats:
+ * - OP_FALSE OP_RETURN <protocol> <json> (standard)
+ * - OP_RETURN <protocol> <json> (legacy)
+ */
+export async function parseOverlayOutput(beefData, outputIndex) {
+    try {
+        const tx = Transaction.fromBEEF(beefData);
+        const txid = tx.id('hex');
+        const output = tx.outputs[outputIndex];
+        if (!output)
+            return { data: null, txid: null };
+        const { fields } = PushDrop.decode(output.lockingScript);
+        return { data: JSON.parse(Utils.toUTF8(fields[0])), txid };
+    }
+    catch {
+        return { data: null, txid: null };
+    }
+}

package/dist/scripts/payment/build.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Payment building using a2a-bsv wallet.createPayment().
+ *
+ * This replaces the old buildDirectPayment() which used plain P2PKH scripts
+ * and manual UTXO management. The new implementation:
+ * - Uses proper BRC-29 locking scripts via wallet.createPayment()
+ * - Relies on wallet's createAction() for UTXO management
+ * - Uses noSend: true (recipient broadcasts via acceptPayment())
+ */
+import type { PaymentResult } from './types.js';
+/**
+ * Build a BRC-29 payment using the a2a-bsv wallet.
+ *
+ * This creates a payment transaction using proper BRC-29 locking scripts.
+ * The transaction uses noSend: true, meaning:
+ * - The sender does NOT broadcast the transaction
+ * - The recipient broadcasts it when they call acceptPayment()
+ *
+ * @param recipientPubKey - Recipient's compressed public key (66 hex chars, 02/03 prefix)
+ * @param sats - Amount to send in satoshis
+ * @param desc - Optional description for the payment
+ * @returns PaymentResult with BEEF and derivation metadata for the recipient
+ */
+export declare function buildDirectPayment(recipientPubKey: string, sats: number, desc?: string): Promise<PaymentResult>;

package/dist/scripts/payment/build.js

@@ -0,0 +1,54 @@
+/**
+ * Payment building using a2a-bsv wallet.createPayment().
+ *
+ * This replaces the old buildDirectPayment() which used plain P2PKH scripts
+ * and manual UTXO management. The new implementation:
+ * - Uses proper BRC-29 locking scripts via wallet.createPayment()
+ * - Relies on wallet's createAction() for UTXO management
+ * - Uses noSend: true (recipient broadcasts via acceptPayment())
+ */
+import { NETWORK, WALLET_DIR } from '../config.js';
+import { BSVAgentWallet } from '../../core/index.js';
+async function getBSVAgentWallet() {
+    return BSVAgentWallet;
+}
+/**
+ * Build a BRC-29 payment using the a2a-bsv wallet.
+ *
+ * This creates a payment transaction using proper BRC-29 locking scripts.
+ * The transaction uses noSend: true, meaning:
+ * - The sender does NOT broadcast the transaction
+ * - The recipient broadcasts it when they call acceptPayment()
+ *
+ * @param recipientPubKey - Recipient's compressed public key (66 hex chars, 02/03 prefix)
+ * @param sats - Amount to send in satoshis
+ * @param desc - Optional description for the payment
+ * @returns PaymentResult with BEEF and derivation metadata for the recipient
+ */
+export async function buildDirectPayment(recipientPubKey, sats, desc) {
+    // Validate recipient pubkey format
+    if (!/^0[23][0-9a-fA-F]{64}$/.test(recipientPubKey)) {
+        throw new Error('Recipient must be a compressed public key (66 hex chars starting with 02 or 03)');
+    }
+    const BSVAgentWallet = await getBSVAgentWallet();
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    try {
+        const result = await wallet.createPayment({
+            to: recipientPubKey,
+            satoshis: sats,
+            description: desc || 'agent payment',
+        });
+        // Return format compatible with existing code
+        return {
+            beef: result.beef,
+            txid: result.txid,
+            satoshis: result.satoshis,
+            derivationPrefix: result.derivationPrefix,
+            derivationSuffix: result.derivationSuffix,
+            senderIdentityKey: result.senderIdentityKey,
+        };
+    }
+    finally {
+        await wallet.destroy();
+    }
+}

package/dist/scripts/payment/commands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Payment CLI commands: pay, verify, accept.
+ */
+/**
+ * Pay command: send satoshis to another agent.
+ */
+export declare function cmdPay(pubkey: string | undefined, satoshis: string | undefined, description?: string): Promise<never>;
+/**
+ * Verify command: verify an incoming payment BEEF.
+ */
+export declare function cmdVerify(beefBase64: string | undefined): Promise<never>;
+/**
+ * Accept command: accept and internalize a payment.
+ */
+export declare function cmdAccept(beef: string | undefined, derivationPrefix: string | undefined, derivationSuffix: string | undefined, senderIdentityKey: string | undefined, description?: string): Promise<never>;

package/dist/scripts/payment/commands.js

@@ -0,0 +1,73 @@
+/**
+ * Payment CLI commands: pay, verify, accept.
+ */
+import { NETWORK, WALLET_DIR } from '../config.js';
+import { ok, fail } from '../output.js';
+import { buildDirectPayment } from './build.js';
+import { BSVAgentWallet } from '../../core/index.js';
+async function getBSVAgentWallet() {
+    return BSVAgentWallet;
+}
+/**
+ * Pay command: send satoshis to another agent.
+ */
+export async function cmdPay(pubkey, satoshis, description) {
+    if (!pubkey || !satoshis) {
+        return fail('Usage: pay <pubkey> <satoshis> [description]');
+    }
+    const sats = parseInt(satoshis, 10);
+    if (isNaN(sats) || sats <= 0) {
+        return fail('satoshis must be a positive integer');
+    }
+    try {
+        const payment = await buildDirectPayment(pubkey, sats, description || 'agent payment');
+        return ok(payment);
+    }
+    catch (err) {
+        return fail(err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * Verify command: verify an incoming payment BEEF.
+ */
+export async function cmdVerify(beefBase64) {
+    if (!beefBase64) {
+        return fail('Usage: verify <beef_base64>');
+    }
+    const BSVAgentWallet = await getBSVAgentWallet();
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    try {
+        const result = wallet.verifyPayment({ beef: beefBase64 });
+        await wallet.destroy();
+        return ok(result);
+    }
+    catch (err) {
+        await wallet.destroy();
+        return fail(err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * Accept command: accept and internalize a payment.
+ */
+export async function cmdAccept(beef, derivationPrefix, derivationSuffix, senderIdentityKey, description) {
+    if (!beef || !derivationPrefix || !derivationSuffix || !senderIdentityKey) {
+        return fail('Usage: accept <beef> <prefix> <suffix> <senderKey> [description]');
+    }
+    const BSVAgentWallet = await getBSVAgentWallet();
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    try {
+        const receipt = await wallet.acceptPayment({
+            beef,
+            derivationPrefix,
+            derivationSuffix,
+            senderIdentityKey,
+            description: description || undefined,
+        });
+        await wallet.destroy();
+        return ok(receipt);
+    }
+    catch (err) {
+        await wallet.destroy();
+        return fail(err instanceof Error ? err.message : String(err));
+    }
+}