openclaw-overlay-plugin 0.8.15 → 0.8.17

package/dist/src/core/wallet.js

@@ -1,256 +0,0 @@
-/**
- * @a2a-bsv/core — BSVAgentWallet
- *
- * High-level wallet class for AI agent-to-agent BSV payments.
- * Wraps @bsv/wallet-toolbox's Wallet + StorageKnex with a clean,
- * minimal API surface designed for automated agent use.
- */
-import { PrivateKey, CachedKeyDeriver } from '@bsv/sdk';
-import { Wallet, WalletStorageManager, Services, Monitor, StorageKnex, randomBytesHex, ChaintracksServiceClient, } from '@bsv/wallet-toolbox';
-import knexLib from 'knex';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import debug from 'debug';
-const log = debug('openclaw:plugin:overlay:wallet');
-import { toChain, DEFAULT_TAAL_API_KEYS, DEFAULT_DB_NAME } from './config.js';
-import { buildPayment } from './payment.js';
-import { verifyPayment, acceptPayment } from './verify.js';
-/** Filename for the persisted wallet identity JSON. */
-const IDENTITY_FILE = 'wallet-identity.json';
-/**
- * BSVAgentWallet — the primary class for agent-to-agent BSV payments.
- *
- * Usage:
- * ```ts
- * // Create a new wallet (generates keys)
- * const wallet = await BSVAgentWallet.load({ network: 'testnet', storageDir: './agent-wallet' });
- *
- * // Load an existing wallet
- * const wallet = await BSVAgentWallet.load({ network: 'testnet', storageDir: './agent-wallet' });
- *
- * // Make a payment
- * const payment = await wallet.createPayment({ to: recipientPubKey, satoshis: 500 });
- *
- * // Verify and accept a payment
- * const verification = wallet.verifyPayment({ beef: payment.beef });
- * if (verification.valid) {
- *   await wallet.acceptPayment({ beef: payment.beef, ...derivationInfo });
- * }
- * ```
- */
-export class BSVAgentWallet {
-    /** @internal — exposed for advanced operations (e.g. direct internalizeAction) */
-    _setup;
-    constructor(setup) {
-        this._setup = setup;
-    }
-    // ---------------------------------------------------------------------------
-    // Factory methods
-    // ---------------------------------------------------------------------------
-    /**
-     * Create a new agent wallet. Generates a fresh root key and persists it.
-     * The SQLite database and identity file are written to `config.storageDir`.
-     */
-    static async create(config) {
-        log('Creating new wallet in: %s', config.storageDir);
-        // Generate a new root key (or use one provided in config)
-        const rootKeyHex = config.rootKeyHex ?? PrivateKey.fromRandom().toHex();
-        const rootKey = PrivateKey.fromHex(rootKeyHex);
-        const identityKey = rootKey.toPublicKey().toString(); // toString() defaults to compressed hex
-        // Ensure the storage directory exists
-        fs.mkdirSync(config.storageDir, { recursive: true });
-        // Persist identity for later loading
-        const identity = {
-            rootKeyHex,
-            identityKey,
-            network: config.network,
-        };
-        const identityPath = path.join(config.storageDir, IDENTITY_FILE);
-        fs.writeFileSync(identityPath, JSON.stringify(identity, null, 2), 'utf-8');
-        // Build the wallet
-        const setup = await BSVAgentWallet.buildSetup(config, rootKeyHex);
-        return new BSVAgentWallet(setup);
-    }
-    /**
-     * Load an existing agent wallet from its storage directory.
-     * Reads the persisted identity file and re-initializes the wallet.
-     */
-    static async load(config) {
-        log('Loading wallet from: %s', config.storageDir);
-        const identityPath = path.join(config.storageDir, IDENTITY_FILE);
-        if (!fs.existsSync(identityPath)) {
-            if (config.createIfMissing === false) {
-                log('Wallet not found and createIfMissing is false');
-                throw new Error(`No wallet found in ${config.storageDir}`);
-            }
-            return this.create(config);
-        }
-        const identity = JSON.parse(fs.readFileSync(identityPath, 'utf-8'));
-        const rootKeyHex = config.rootKeyHex ?? identity.rootKeyHex;
-        const setup = await BSVAgentWallet.buildSetup(config, rootKeyHex);
-        return new BSVAgentWallet(setup);
-    }
-    // ---------------------------------------------------------------------------
-    // Wallet lifecycle
-    // ---------------------------------------------------------------------------
-    /**
-     * Get this wallet's public identity key (compressed hex, 33 bytes).
-     * This is the key other agents use to send payments to you.
-     */
-    async getIdentityKey() {
-        return this._setup.identityKey;
-    }
-    /**
-     * Get the wallet's current receive address for the active network.
-     */
-    async getAddress() {
-        const network = this._setup.network || 'mainnet';
-        return this._setup.rootKey.toPublicKey().toAddress(network);
-    }
-    /**
-     * Get the wallet's current balance in satoshis.
-     *
-     * Uses the BRC-100 wallet's balance method which sums spendable outputs
-     * in the default basket.
-     */
-    async getBalance() {
-        return await this._setup.wallet.balance();
-    }
-    /**
-     * Cleanly shut down the wallet, releasing database connections and
-     * stopping the background monitor.
-     */
-    async destroy() {
-        if (this._setup.monitor) {
-            await this._setup.monitor.destroy();
-        }
-        if (this._setup.wallet) {
-            await this._setup.wallet.destroy();
-        }
-        await this._setup.storage.destroy();
-    }
-    // ---------------------------------------------------------------------------
-    // Payment creation (sender/payer side)
-    // ---------------------------------------------------------------------------
-    /**
-     * Build a BRC-29 payment to another agent.
-     *
-     * The transaction is created with `noSend: true` — the sender does NOT
-     * broadcast it. Instead, the Atomic BEEF and derivation metadata are
-     * returned so they can be transmitted to the recipient, who will
-     * verify and internalize (broadcast) the payment.
-     *
-     * @param params.to — Recipient's compressed public key (hex).
-     * @param params.satoshis — Amount in satoshis.
-     * @param params.description — Optional human-readable note.
-     */
-    async createPayment(params) {
-        return buildPayment(this._setup, params);
-    }
-    // ---------------------------------------------------------------------------
-    // Payment verification & acceptance (receiver/merchant side)
-    // ---------------------------------------------------------------------------
-    /**
-     * Verify an incoming Atomic BEEF payment.
-     *
-     * This performs structural validation and SPV verification via tx.verify().
-     */
-    async verifyPayment(params) {
-        return await verifyPayment(params);
-    }
-    /**
-     * Accept (internalize) a verified payment into this wallet.
-     *
-     * Uses the BRC-29 wallet payment protocol to derive the correct key
-     * and claim the output. This triggers SPV verification and, if the
-     * transaction hasn't been broadcast yet, broadcasts it.
-     */
-    async acceptPayment(params) {
-        return acceptPayment(this._setup, params);
-    }
-    // ---------------------------------------------------------------------------
-    // Access to underlying toolbox objects (for advanced use)
-    // ---------------------------------------------------------------------------
-    /** Get the underlying wallet-toolbox SetupWallet for advanced operations. */
-    getSetup() {
-        return this._setup;
-    }
-    // ---------------------------------------------------------------------------
-    // Private helpers
-    // ---------------------------------------------------------------------------
-    /**
-     * Internal: manually construct a BRC-100 wallet backed by SQLite.
-     *
-     * We build this by hand instead of using Setup.createWalletSQLite because
-     * the toolbox has a bug where its internal randomBytesHex is a stub.
-     * We use the same components but wire them up correctly.
-     */
-    static async buildSetup(config, rootKeyHex) {
-        const chain = toChain(config.network);
-        log('Building setup for chain: %s (network: %s)', chain, config.network);
-        const taalApiKey = config.taalApiKey ?? DEFAULT_TAAL_API_KEYS[chain];
-        const rootKey = PrivateKey.fromHex(rootKeyHex);
-        const identityKey = rootKey.toPublicKey().toString();
-        // 1. Key derivation
-        const keyDeriver = new CachedKeyDeriver(rootKey);
-        // 2. Storage manager (empty initially)
-        const storage = new WalletStorageManager(identityKey);
-        // 3. Network services (ARC broadcasting, chain tracking, etc.)
-        const serviceOptions = Services.createDefaultOptions(chain);
-        const chaintracksUrl = process['en' + 'v'].BSV_CHAINTRACKS_URL || 'https://chaintracks-us-1.bsvb.tech';
-        const arcUrl = process['en' + 'v'].BSV_ARC_URL;
-        const isTestMode = config.enableMonitor === false;
-        if (!isTestMode) {
-            serviceOptions.chaintracks = new ChaintracksServiceClient(chain, chaintracksUrl);
-            if (arcUrl) {
-                serviceOptions.arcUrl = arcUrl;
-            }
-        }
-        serviceOptions.taalApiKey = taalApiKey;
-        const services = new Services(serviceOptions);
-        // 4. Background monitor
-        const monopts = Monitor.createDefaultWalletMonitorOptions(chain, storage, services);
-        const monitor = new Monitor(monopts);
-        if (!isTestMode) {
-            monitor.addDefaultTasks();
-        }
-        else {
-            // In test mode, we clear all tasks to ensure no background activity
-            monitor.tasks = [];
-        }
-        // 5. The BRC-100 Wallet
-        const wallet = isTestMode ? undefined : new Wallet({ chain, keyDeriver, storage, services, monitor });
-        // 6. SQLite storage via knex
-        const filePath = path.join(config.storageDir, `${DEFAULT_DB_NAME}.sqlite`);
-        const knex = knexLib({
-            client: 'sqlite3',
-            connection: { filename: filePath },
-            useNullAsDefault: true,
-        });
-        // Fee model: configurable via BSV_FEE_MODEL env var (default: 100 sat/KB)
-        const feeModelValue = config.feeModel ??
-            (process['en' + 'v'].BSV_FEE_MODEL ? parseInt(process['en' + 'v'].BSV_FEE_MODEL, 10) : 100);
-        const activeStorage = new StorageKnex({
-            chain,
-            knex,
-            commissionSatoshis: 0,
-            commissionPubKeyHex: undefined,
-            feeModel: { model: 'sat/kb', value: feeModelValue },
-        });
-        await activeStorage.migrate(DEFAULT_DB_NAME, randomBytesHex(33));
-        await activeStorage.makeAvailable();
-        await storage.addWalletStorageProvider(activeStorage);
-        await activeStorage.findOrInsertUser(identityKey);
-        return {
-            rootKey,
-            identityKey,
-            keyDeriver,
-            chain,
-            network: config.network,
-            storage,
-            services: isTestMode ? undefined : services,
-            monitor: isTestMode ? undefined : monitor,
-            wallet,
-        };
-    }
-}

package/dist/src/scripts/baemail/commands.d.ts

@@ -1,35 +0,0 @@
-export interface BaemailLogEntry {
-    requestId: string;
-    from: string;
-    to?: string;
-    paidSats: number;
-    deliverySuccess: boolean;
-    refundStatus?: 'pending' | 'completed';
-    refundTxid?: string;
-    _lineIdx?: number;
-    ts?: number;
-    senderName?: string;
-    messageLength?: number;
-    tier?: string;
-    deliveryChannel?: string;
-    deliveryError?: string | null;
-    paymentTxid?: string;
-    timestamp?: string;
-}
-/**
- * Log a baemail delivery event.
- */
-export declare function logBaemailDelivery(entry: BaemailLogEntry): void;
-export declare function loadBaemailConfig(): Promise<any>;
-/**
- * List recent baemail deliveries.
- */
-export declare function cmdBaemailLog(limitStr?: string): Promise<any>;
-export declare function cmdBaemailSetup(priceSatsStr: string, prioritySats?: string, urgentSats?: string, channel?: string): Promise<any>;
-export declare function cmdBaemailConfig(): Promise<any>;
-export declare function cmdBaemailBlock(pubkey: string): Promise<any>;
-export declare function cmdBaemailUnblock(pubkey: string): Promise<any>;
-/**
- * Refund a failed baemail delivery.
- */
-export declare function cmdBaemailRefund(requestId: string | undefined): Promise<any>;

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

@@ -1,282 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import path from 'node:path';
-import os from 'node:os';
-import fs from 'node:fs';
-import process from 'node:process';
-import { ok, fail } from '../output.js';
-import { loadIdentity, deriveWalletAddress } from '../wallet/identity.js';
-import { NETWORK } from '../config.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// Define paths relative to home directory
-const PATHS = {
-    walletIdentity: path.join(os.homedir(), '.openclaw', 'bsv-wallet', 'wallet-identity.json'),
-    baemailLog: path.join(os.homedir(), '.openclaw', 'openclaw-overlay', 'baemail-deliveries.jsonl'),
-    baemailConfig: path.join(os.homedir(), '.openclaw', 'openclaw-overlay', 'baemail-config.json'),
-    baemailBlocklist: path.join(os.homedir(), '.openclaw', 'openclaw-overlay', 'baemail-blocklist.json'),
-};
-/**
- * Log a baemail delivery event.
- */
-export function logBaemailDelivery(entry) {
-    try {
-        const dir = path.dirname(PATHS.baemailLog);
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        fs.appendFileSync(PATHS.baemailLog, JSON.stringify({ ...entry, ts: Date.now() }) + '\n');
-    }
-    catch { }
-}
-export async function loadBaemailConfig() {
-    const defaults = {
-        enabled: true,
-        priceSats: 100,
-        autoRefund: true,
-        blocklist: [],
-        maxMessageLength: 4000,
-        deliveryChannel: 'agent-hook',
-        tiers: {
-            standard: 100,
-            priority: 500,
-            urgent: 1000
-        }
-    };
-    if (!fs.existsSync(PATHS.baemailConfig)) {
-        return defaults;
-    }
-    try {
-        const config = JSON.parse(fs.readFileSync(PATHS.baemailConfig, 'utf-8'));
-        return { ...defaults, ...config };
-    }
-    catch {
-        return defaults;
-    }
-}
-async function fetchWithTimeout(url, options = {}) {
-    const { timeout = 15000 } = options;
-    const controller = new AbortController();
-    const id = setTimeout(() => controller.abort(), timeout);
-    try {
-        const response = await fetch(url, {
-            ...options,
-            signal: controller.signal
-        });
-        clearTimeout(id);
-        return response;
-    }
-    catch (err) {
-        clearTimeout(id);
-        throw err;
-    }
-}
-/**
- * List recent baemail deliveries.
- */
-export async function cmdBaemailLog(limitStr) {
-    const limit = parseInt(limitStr || '20', 10) || 20;
-    if (!fs.existsSync(PATHS.baemailLog)) {
-        return ok({ log: [], count: 0 });
-    }
-    const lines = fs.readFileSync(PATHS.baemailLog, 'utf-8').split('\n').filter((l) => l.trim());
-    const entries = lines.map((l) => {
-        try {
-            return JSON.parse(l);
-        }
-        catch {
-            return null;
-        }
-    }).filter(Boolean);
-    const recent = entries.slice(-limit).reverse();
-    return ok({ log: recent, count: entries.length, showing: recent.length });
-}
-export async function cmdBaemailSetup(priceSatsStr, prioritySats, urgentSats, channel) {
-    const standard = parseInt(priceSatsStr, 10) || 100;
-    const priority = parseInt(prioritySats || '', 10) || (standard * 5);
-    const urgent = parseInt(urgentSats || '', 10) || (standard * 10);
-    const config = {
-        enabled: true,
-        priceSats: standard,
-        autoRefund: true,
-        deliveryChannel: channel || 'agent-hook',
-        tiers: { standard, priority, urgent }
-    };
-    const dir = path.dirname(PATHS.baemailConfig);
-    if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(PATHS.baemailConfig, JSON.stringify(config, null, 2));
-    return ok({ message: `Baemail setup complete.`, config });
-}
-export async function cmdBaemailConfig() {
-    const config = await loadBaemailConfig();
-    return ok(config);
-}
-export async function cmdBaemailBlock(pubkey) {
-    if (!pubkey)
-        return fail('Usage: baemail-block <pubkey>');
-    let blocklist = [];
-    if (fs.existsSync(PATHS.baemailBlocklist)) {
-        try {
-            blocklist = JSON.parse(fs.readFileSync(PATHS.baemailBlocklist, 'utf-8'));
-        }
-        catch {
-            blocklist = [];
-        }
-    }
-    if (!blocklist.includes(pubkey))
-        blocklist.push(pubkey);
-    fs.writeFileSync(PATHS.baemailBlocklist, JSON.stringify(blocklist, null, 2));
-    return ok({ blocked: true, pubkey, count: blocklist.length });
-}
-export async function cmdBaemailUnblock(pubkey) {
-    if (!pubkey)
-        return fail('Usage: baemail-unblock <pubkey>');
-    let blocklist = [];
-    if (fs.existsSync(PATHS.baemailBlocklist)) {
-        try {
-            blocklist = JSON.parse(fs.readFileSync(PATHS.baemailBlocklist, 'utf-8'));
-        }
-        catch {
-            blocklist = [];
-        }
-    }
-    blocklist = blocklist.filter(p => p !== pubkey);
-    fs.writeFileSync(PATHS.baemailBlocklist, JSON.stringify(blocklist, null, 2));
-    return ok({ unblocked: true, pubkey, count: blocklist.length });
-}
-/**
- * Refund a failed baemail delivery.
- */
-export async function cmdBaemailRefund(requestId) {
-    if (!requestId)
-        return fail('Usage: baemail-refund <requestId>');
-    if (!fs.existsSync(PATHS.baemailLog)) {
-        return fail('No baemail log found');
-    }
-    // Find the entry
-    const lines = fs.readFileSync(PATHS.baemailLog, 'utf-8').split('\n').filter((l) => l.trim());
-    const entries = lines.map((l, idx) => {
-        try {
-            return { ...JSON.parse(l), _lineIdx: idx };
-        }
-        catch {
-            return null;
-        }
-    }).filter(Boolean);
-    const entry = entries.find(e => e.requestId === requestId);
-    if (!entry) {
-        return fail(`Request ${requestId} not found in baemail log`);
-    }
-    if (entry.deliverySuccess) {
-        return fail('This delivery was successful — no refund needed');
-    }
-    if (entry.refundStatus === 'completed') {
-        return fail('Refund already processed for this request');
-    }
-    // Load wallet and SDK
-    const { identityKey, privKey: rootKey } = await loadIdentity();
-    const walletIdentityRaw = fs.readFileSync(PATHS.walletIdentity, 'utf-8');
-    const walletIdentity = JSON.parse(walletIdentityRaw);
-    // Dynamic import SDK
-    let sdk;
-    try {
-        sdk = await import('@bsv/sdk');
-    }
-    catch {
-        return fail('Cannot load @bsv/sdk for refund transaction');
-    }
-    const { Transaction, P2PKH, PrivateKey, PublicKey, Hash } = sdk;
-    // Calculate refund amount
-    const refundSats = entry.paidSats - 1; // Keep 1 sat for tx fee
-    if (refundSats < 1) {
-        return fail('Amount too small to refund');
-    }
-    // Derive refund address from sender's identity key
-    const senderPubKey = PublicKey.fromString(entry.from);
-    const refundAddress = senderPubKey.toAddress(NETWORK).toString();
-    try {
-        // Load UTXOs - Derive local address correctly
-        const { address } = await deriveWalletAddress(rootKey);
-        const wocNet = NETWORK === 'mainnet' ? 'main' : 'test';
-        const utxosResp = await fetchWithTimeout(`https://api.whatsonchain.com/v1/bsv/${wocNet}/address/${address}/unspent/all`);
-        const data = await utxosResp.json();
-        const utxos = data.result || [];
-        if (!utxos || utxos.length === 0) {
-            return fail(`No UTXOs available for refund at ${address}`);
-        }
-        // Build transaction
-        const tx = new Transaction();
-        let totalInput = 0;
-        for (const utxo of utxos) {
-            if (totalInput >= refundSats + 50)
-                break;
-            tx.addInput({
-                sourceTXID: utxo.tx_hash,
-                sourceOutputIndex: utxo.tx_pos,
-                sourceSatoshis: utxo.value,
-                script: new P2PKH().lock(rootKey.toPublicKey().toAddress(NETWORK)).toHex(),
-                unlockingScriptTemplate: new P2PKH().unlock(rootKey),
-            });
-            totalInput += utxo.value;
-        }
-        if (totalInput < refundSats + 10) {
-            return fail('Insufficient funds for refund');
-        }
-        // Refund output
-        tx.addOutput({
-            satoshis: refundSats,
-            lockingScript: new P2PKH().lock(refundAddress),
-        });
-        // Change output
-        const fee = 10;
-        const change = totalInput - refundSats - fee;
-        if (change > 1) {
-            tx.addOutput({
-                satoshis: change,
-                lockingScript: new P2PKH().lock(rootKey.toPublicKey().toAddress(NETWORK)),
-            });
-        }
-        await tx.sign();
-        // 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/${wocNet}/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}`);
-        }
-        const txid = tx.id('hex');
-        // Update log entry
-        const updatedLines = lines.map((l, idx) => {
-            if (idx === entry._lineIdx) {
-                const updated = { ...JSON.parse(l), refundStatus: 'completed', refundTxid: txid, refundedAt: new Date().toISOString() };
-                return JSON.stringify(updated);
-            }
-            return l;
-        });
-        fs.writeFileSync(PATHS.baemailLog, updatedLines.join('\n') + '\n');
-        return ok({
-            refunded: true,
-            requestId,
-            refundSats,
-            refundAddress,
-            txid,
-            note: `Refunded ${refundSats} sats to sender`,
-        });
-    }
-    catch (err) {
-        return fail(`Refund failed: ${err.message}`);
-    }
-}

package/dist/src/scripts/baemail/handler.d.ts

@@ -1,36 +0,0 @@
-/**
- * Baemail service handler - processes incoming paid messages.
- */
-interface BaemailInput {
-    message?: string;
-    senderName?: string;
-    replyIdentityKey?: string;
-}
-interface ServiceMessage {
-    id: string;
-    from: string;
-    payload?: {
-        input?: BaemailInput;
-        payment?: any;
-    };
-}
-interface ProcessResult {
-    id: string;
-    type: string;
-    serviceId: string;
-    action: string;
-    tier?: string;
-    deliverySuccess?: boolean;
-    deliveryError?: string | null | undefined;
-    paymentAccepted?: boolean;
-    paymentTxid?: string;
-    satoshisReceived?: number;
-    from: string;
-    ack: boolean;
-    reason?: string | null;
-}
-/**
- * Process incoming baemail service request.
- */
-export declare function processBaemail(msg: ServiceMessage, identityKey: string, privKey: any): Promise<ProcessResult>;
-export {};