openclaw-overlay-plugin 0.7.22

package/dist/scripts/utils/storage.js

@@ -0,0 +1,211 @@
+/**
+ * File-based storage helpers for registration, services, and queues.
+ */
+import fs from 'node:fs';
+import { OVERLAY_STATE_DIR, PATHS } from '../config.js';
+/**
+ * Ensure the overlay state directory exists.
+ */
+export function ensureStateDir() {
+    fs.mkdirSync(OVERLAY_STATE_DIR, { recursive: true });
+}
+/**
+ * Load registration data from disk.
+ */
+export function loadRegistration() {
+    try {
+        if (fs.existsSync(PATHS.registration)) {
+            return JSON.parse(fs.readFileSync(PATHS.registration, 'utf-8'));
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return null;
+}
+/**
+ * Save registration data to disk.
+ */
+export function saveRegistration(data) {
+    ensureStateDir();
+    fs.writeFileSync(PATHS.registration, JSON.stringify(data, null, 2), 'utf-8');
+}
+/**
+ * Delete registration file.
+ */
+export function deleteRegistration() {
+    try {
+        fs.unlinkSync(PATHS.registration);
+    }
+    catch {
+        // Ignore if file doesn't exist
+    }
+}
+/**
+ * Load services list from disk.
+ */
+export function loadServices() {
+    try {
+        if (fs.existsSync(PATHS.services)) {
+            return JSON.parse(fs.readFileSync(PATHS.services, 'utf-8'));
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return [];
+}
+/**
+ * Save services list to disk.
+ */
+export function saveServices(services) {
+    ensureStateDir();
+    fs.writeFileSync(PATHS.services, JSON.stringify(services, null, 2), 'utf-8');
+}
+/**
+ * Load X verifications from disk.
+ */
+export function loadXVerifications() {
+    try {
+        if (fs.existsSync(PATHS.xVerifications)) {
+            return JSON.parse(fs.readFileSync(PATHS.xVerifications, 'utf-8'));
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return [];
+}
+/**
+ * Save X verifications to disk.
+ */
+export function saveXVerifications(verifications) {
+    ensureStateDir();
+    fs.writeFileSync(PATHS.xVerifications, JSON.stringify(verifications, null, 2), 'utf-8');
+}
+/**
+ * Append a line to a JSONL file.
+ */
+export function appendToJsonl(filePath, entry) {
+    ensureStateDir();
+    fs.appendFileSync(filePath, JSON.stringify(entry) + '\n');
+}
+/**
+ * Read and parse a JSONL file.
+ */
+export function readJsonl(filePath) {
+    if (!fs.existsSync(filePath))
+        return [];
+    const lines = fs.readFileSync(filePath, 'utf-8').trim().split('\n').filter(Boolean);
+    return lines.map(line => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    }).filter(Boolean);
+}
+/**
+ * Load stored change BEEF data.
+ */
+export function loadStoredChange() {
+    try {
+        if (fs.existsSync(PATHS.latestChange)) {
+            return JSON.parse(fs.readFileSync(PATHS.latestChange, 'utf-8'));
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return null;
+}
+/**
+ * Save stored change BEEF data.
+ */
+export function saveStoredChange(data) {
+    ensureStateDir();
+    fs.writeFileSync(PATHS.latestChange, JSON.stringify(data));
+}
+/**
+ * Delete stored change file.
+ */
+export function deleteStoredChange() {
+    try {
+        fs.unlinkSync(PATHS.latestChange);
+    }
+    catch {
+        // Ignore if file doesn't exist
+    }
+}
+/**
+ * Clean up old entries from service queue.
+ * Removes entries older than maxAgeMs or entries with final statuses older than finalStatusMaxAgeMs.
+ */
+export function cleanupServiceQueue(maxAgeMs = 24 * 60 * 60 * 1000, finalStatusMaxAgeMs = 2 * 60 * 60 * 1000) {
+    if (!fs.existsSync(PATHS.serviceQueue))
+        return;
+    const now = Date.now();
+    const finalStatuses = ['fulfilled', 'rejected', 'delivery_failed', 'failed', 'error'];
+    const lines = fs.readFileSync(PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+    const keptLines = [];
+    let removedCount = 0;
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            const entryAge = now - (entry._ts || 0);
+            // Always keep pending entries that aren't too old
+            if (entry.status === 'pending' && entryAge < maxAgeMs) {
+                keptLines.push(line);
+                continue;
+            }
+            // Keep final status entries only if they're recent
+            if (finalStatuses.includes(entry.status) && entryAge < finalStatusMaxAgeMs) {
+                keptLines.push(line);
+                continue;
+            }
+            // Remove this entry
+            removedCount++;
+        }
+        catch {
+            // Keep malformed entries to avoid data loss
+            keptLines.push(line);
+        }
+    }
+    if (removedCount > 0) {
+        fs.writeFileSync(PATHS.serviceQueue, keptLines.join('\n') + (keptLines.length ? '\n' : ''));
+        console.error(JSON.stringify({ event: 'queue-cleanup', removed: removedCount, kept: keptLines.length }));
+    }
+}
+/**
+ * Atomically update a service queue entry status.
+ * Returns true if the entry was found and updated, false otherwise.
+ */
+export function updateServiceQueueStatus(requestId, newStatus, additionalFields = {}) {
+    if (!fs.existsSync(PATHS.serviceQueue))
+        return false;
+    const lines = fs.readFileSync(PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+    let updated = false;
+    const updatedLines = lines.map(line => {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.requestId === requestId) {
+                updated = true;
+                return JSON.stringify({
+                    ...entry,
+                    status: newStatus,
+                    ...additionalFields,
+                    updatedAt: Date.now()
+                });
+            }
+            return line;
+        }
+        catch {
+            return line;
+        }
+    });
+    if (updated) {
+        fs.writeFileSync(PATHS.serviceQueue, updatedLines.join('\n') + '\n');
+    }
+    return updated;
+}

package/dist/scripts/utils/woc.d.ts

@@ -0,0 +1,26 @@
+/**
+ * WhatsOnChain API helpers with retry logic and rate limiting.
+ */
+/**
+ * Fetch from WhatsonChain with optional API key auth and retry logic.
+ * Retries on 429 (rate limit) and 5xx errors with exponential backoff.
+ * Includes timeout to prevent hanging indefinitely.
+ */
+export declare function wocFetch(urlPath: string, options?: RequestInit, maxRetries?: number, timeoutMs?: number): Promise<Response>;
+/**
+ * Fetch with timeout using AbortController.
+ */
+export declare function fetchWithTimeout(url: string, options?: RequestInit, timeoutMs?: number): Promise<Response>;
+/**
+ * Fetch a pre-built BEEF from WhatsonChain for a given txid.
+ * WoC returns raw binary BEEF that includes the full source chain and merkle proofs.
+ */
+export declare function fetchBeefFromWoC(txid: string): Promise<Uint8Array | null>;
+/**
+ * Get the WoC base URL for the current network.
+ */
+export declare function getWocBaseUrl(): string;
+/**
+ * Get the explorer base URL for the current network.
+ */
+export declare function getExplorerBaseUrl(): string;

package/dist/scripts/utils/woc.js

@@ -0,0 +1,91 @@
+/**
+ * WhatsOnChain API helpers with retry logic and rate limiting.
+ */
+import { NETWORK, WOC_API_KEY } from '../config.js';
+/**
+ * Fetch from WhatsonChain with optional API key auth and retry logic.
+ * Retries on 429 (rate limit) and 5xx errors with exponential backoff.
+ * Includes timeout to prevent hanging indefinitely.
+ */
+export async function wocFetch(urlPath, options = {}, maxRetries = 3, timeoutMs = 30000) {
+    const wocNet = NETWORK === 'mainnet' ? 'main' : 'test';
+    const base = `https://api.whatsonchain.com/v1/bsv/${wocNet}`;
+    const url = urlPath.startsWith('http') ? urlPath : `${base}${urlPath}`;
+    const headers = { ...(options.headers || {}) };
+    if (WOC_API_KEY) {
+        headers['Authorization'] = `Bearer ${WOC_API_KEY}`;
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            const resp = await fetch(url, { ...options, headers, signal: controller.signal });
+            clearTimeout(timeout);
+            // Retry on 429 (rate limit) or 5xx (server error)
+            if ((resp.status === 429 || resp.status >= 500) && attempt < maxRetries) {
+                const delayMs = Math.min(1000 * Math.pow(2, attempt), 8000);
+                await new Promise(r => setTimeout(r, delayMs));
+                continue;
+            }
+            return resp;
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < maxRetries) {
+                const delayMs = Math.min(1000 * Math.pow(2, attempt), 8000);
+                await new Promise(r => setTimeout(r, delayMs));
+                continue;
+            }
+        }
+    }
+    throw lastError || new Error('WoC fetch failed after retries');
+}
+/**
+ * Fetch with timeout using AbortController.
+ */
+export async function fetchWithTimeout(url, options = {}, timeoutMs = 15000) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const resp = await fetch(url, { ...options, signal: controller.signal });
+        return resp;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Fetch a pre-built BEEF from WhatsonChain for a given txid.
+ * WoC returns raw binary BEEF that includes the full source chain and merkle proofs.
+ */
+export async function fetchBeefFromWoC(txid) {
+    try {
+        const resp = await wocFetch(`/tx/${txid}/beef`);
+        if (!resp.ok)
+            return null;
+        const hexStr = (await resp.text()).trim();
+        if (!hexStr || hexStr.length < 8)
+            return null;
+        const bytes = hexStr.match(/.{2}/g).map(h => parseInt(h, 16));
+        return new Uint8Array(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the WoC base URL for the current network.
+ */
+export function getWocBaseUrl() {
+    const wocNet = NETWORK === 'mainnet' ? 'main' : 'test';
+    return `https://api.whatsonchain.com/v1/bsv/${wocNet}`;
+}
+/**
+ * Get the explorer base URL for the current network.
+ */
+export function getExplorerBaseUrl() {
+    return NETWORK === 'mainnet'
+        ? 'https://whatsonchain.com'
+        : 'https://test.whatsonchain.com';
+}

package/dist/scripts/wallet/balance.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Wallet balance commands: balance, import, refund.
+ */
+/**
+ * Balance command: show wallet balance.
+ */
+export declare function cmdBalance(): Promise<never>;
+/**
+ * Import command: import external UTXO with merkle proof.
+ *
+ * This function handles both confirmed and unconfirmed transactions.
+ * For unconfirmed transactions, it uses BEEF from WoC which includes
+ * the source chain back to confirmed ancestors (SPV-compliant).
+ *
+ * If the transaction isn't yet on WoC (just broadcast), it will poll
+ * with exponential backoff for up to 60 seconds.
+ */
+export declare function cmdImport(txidArg: string | undefined, voutStr?: string): Promise<never>;
+/**
+ * Refund command: sweep wallet to an address.
+ */
+export declare function cmdRefund(targetAddress: string | undefined): Promise<void>;

package/dist/scripts/wallet/balance.js

@@ -0,0 +1,240 @@
+/**
+ * Wallet balance commands: balance, import, refund.
+ */
+import fs from 'node:fs';
+import { NETWORK, WALLET_DIR, PATHS } from '../config.js';
+import { ok, fail } from '../output.js';
+import { wocFetch, fetchBeefFromWoC, getExplorerBaseUrl } from '../utils/woc.js';
+import { buildMerklePathFromTSC } from '../utils/merkle.js';
+import { BSVAgentWallet } from '../../core/index.js';
+async function getBSVAgentWallet() {
+    return BSVAgentWallet;
+}
+// Dynamic import for @bsv/sdk
+let _sdk = null;
+async function getSdk() {
+    if (_sdk)
+        return _sdk;
+    try {
+        _sdk = await import('@bsv/sdk');
+        return _sdk;
+    }
+    catch {
+        const { fileURLToPath } = await import('node:url');
+        const path = await import('node:path');
+        const os = await import('node:os');
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            path.resolve(__dirname, '..', '..', '..', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(__dirname, '..', '..', '..', '..', '..', 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(os.homedir(), 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+        ];
+        for (const p of candidates) {
+            try {
+                _sdk = await import(p);
+                return _sdk;
+            }
+            catch {
+                // Try next
+            }
+        }
+        throw new Error('Cannot find @bsv/sdk. Run setup.sh first.');
+    }
+}
+/**
+ * Sleep helper for polling
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Balance command: show wallet balance.
+ */
+export async function cmdBalance() {
+    const BSVAgentWallet = await getBSVAgentWallet();
+    const sdk = await getSdk();
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const total = await wallet.getBalance();
+    await wallet.destroy();
+    return ok({ walletBalance: total });
+}
+/**
+ * Import command: import external UTXO with merkle proof.
+ *
+ * This function handles both confirmed and unconfirmed transactions.
+ * For unconfirmed transactions, it uses BEEF from WoC which includes
+ * the source chain back to confirmed ancestors (SPV-compliant).
+ *
+ * If the transaction isn't yet on WoC (just broadcast), it will poll
+ * with exponential backoff for up to 60 seconds.
+ */
+export async function cmdImport(txidArg, voutStr) {
+    if (!txidArg) {
+        return fail('Usage: import <txid> [vout]');
+    }
+    const vout = parseInt(voutStr || '0', 10);
+    const txid = txidArg.toLowerCase();
+    if (!/^[0-9a-f]{64}$/.test(txid)) {
+        return fail('Invalid txid — must be 64 hex characters');
+    }
+    const sdk = await getSdk();
+    const BSVAgentWallet = await getBSVAgentWallet();
+    // Poll for transaction on WoC with exponential backoff
+    // This handles the case where user just broadcast and WoC hasn't indexed yet
+    let txInfo = null;
+    const maxWaitMs = 60000; // 60 seconds max
+    const startTime = Date.now();
+    let attempt = 0;
+    while (Date.now() - startTime < maxWaitMs) {
+        const txInfoResp = await wocFetch(`/tx/${txid}`, {}, 1, 10000); // Single retry, 10s timeout
+        if (txInfoResp.ok) {
+            txInfo = await txInfoResp.json();
+            break;
+        }
+        else if (txInfoResp.status === 404) {
+            // Transaction not found yet - wait and retry
+            attempt++;
+            const delayMs = Math.min(1000 * Math.pow(1.5, attempt), 10000); // 1s, 1.5s, 2.25s, ... max 10s
+            console.error(`[import] Transaction not on WoC yet, waiting ${Math.round(delayMs / 1000)}s... (attempt ${attempt})`);
+            await sleep(delayMs);
+            continue;
+        }
+        else {
+            return fail(`Failed to fetch tx info: ${txInfoResp.status}`);
+        }
+    }
+    if (!txInfo) {
+        return fail(`Transaction ${txid} not found on WhatsOnChain after ${Math.round((Date.now() - startTime) / 1000)}s. The transaction may not have been broadcast yet, or the txid may be incorrect.`);
+    }
+    const isConfirmed = txInfo.confirmations && txInfo.confirmations >= 1;
+    const blockHeight = txInfo.blockheight;
+    // Validate output exists
+    if (!txInfo.vout || !txInfo.vout[vout]) {
+        return fail(`Output index ${vout} not found in transaction (has ${txInfo.vout?.length || 0} outputs)`);
+    }
+    let atomicBeefBytes;
+    // Try WoC BEEF first - works for both confirmed and unconfirmed transactions
+    // WoC provides BEEF with full source chain back to confirmed ancestors
+    const wocBeefBytes = await fetchBeefFromWoC(txid);
+    if (wocBeefBytes) {
+        try {
+            const wocBeef = sdk.Beef.fromBinary(Array.from(wocBeefBytes));
+            const foundTx = wocBeef.findTxid(txid);
+            if (foundTx) {
+                // Verify the output exists in the parsed tx
+                const txObj = foundTx.tx || foundTx._tx;
+                if (txObj) {
+                    const output = txObj.outputs[vout];
+                    if (!output) {
+                        return fail(`Output index ${vout} not found in BEEF transaction (has ${txObj.outputs.length} outputs)`);
+                    }
+                }
+                atomicBeefBytes = wocBeef.toBinaryAtomic(txid);
+            }
+        }
+        catch (beefErr) {
+            console.error(`[import] WoC BEEF parse failed: ${beefErr.message}`);
+            // Fall through to manual construction
+        }
+    }
+    // Fallback for confirmed txs: construct BEEF manually using TSC merkle proof
+    if (!atomicBeefBytes && isConfirmed) {
+        try {
+            const rawTxResp = await wocFetch(`/tx/${txid}/hex`);
+            if (!rawTxResp.ok) {
+                return fail(`Failed to fetch raw transaction: ${rawTxResp.status}`);
+            }
+            const rawTxHex = await rawTxResp.text();
+            const sourceTx = sdk.Transaction.fromHex(rawTxHex.trim());
+            const proofResp = await wocFetch(`/tx/${txid}/proof/tsc`);
+            if (!proofResp.ok) {
+                return fail(`Failed to fetch merkle proof: ${proofResp.status}`);
+            }
+            const proofData = await proofResp.json();
+            if (!Array.isArray(proofData) || proofData.length === 0) {
+                return fail('Merkle proof not available from WoC');
+            }
+            const proof = proofData[0];
+            const merklePath = await buildMerklePathFromTSC(txid, proof.index, proof.nodes, blockHeight);
+            sourceTx.merklePath = merklePath;
+            const beef = new sdk.Beef();
+            beef.mergeTransaction(sourceTx);
+            atomicBeefBytes = beef.toBinaryAtomic(txid);
+        }
+        catch (manualErr) {
+            return fail(`Failed to construct BEEF manually: ${manualErr.message}`);
+        }
+    }
+    // If still no BEEF, we can't import
+    if (!atomicBeefBytes) {
+        if (isConfirmed) {
+            return fail(`Transaction ${txid} is confirmed but BEEF construction failed. This is unexpected — please report this issue.`);
+        }
+        else {
+            // Unconfirmed and no BEEF available
+            // This can happen if the funding tx itself spends unconfirmed inputs
+            return fail(`Transaction ${txid} is unconfirmed (${txInfo.confirmations || 0} confirmations) and BEEF is not available.\n\n` +
+                `This usually means the funding transaction spends from other unconfirmed transactions, creating a chain.\n` +
+                `Wait for 1 block confirmation (~10 minutes) and try again, or use a fresh UTXO as the funding source.`);
+        }
+    }
+    // Get output satoshis for reporting
+    const outputSatoshis = txInfo.vout[vout].value != null
+        ? Math.round(txInfo.vout[vout].value * 1e8)
+        : undefined;
+    // Import into wallet
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const identityKey = await wallet.getIdentityKey();
+    try {
+        await wallet._setup.wallet.storage.internalizeAction({
+            tx: Array.from(atomicBeefBytes),
+            outputs: [{
+                    outputIndex: vout,
+                    protocol: 'wallet payment',
+                    paymentRemittance: {
+                        derivationPrefix: sdk.Utils.toBase64(sdk.Utils.toArray('import', 'utf8')),
+                        derivationSuffix: sdk.Utils.toBase64(sdk.Utils.toArray('now', 'utf8')),
+                        senderIdentityKey: identityKey,
+                    },
+                }],
+            description: 'External funding import',
+        });
+        const balance = await wallet.getBalance();
+        await wallet.destroy();
+        const explorerBase = getExplorerBaseUrl();
+        return ok({
+            txid,
+            vout,
+            satoshis: outputSatoshis,
+            blockHeight: blockHeight || null,
+            confirmations: txInfo.confirmations || 0,
+            imported: true,
+            unconfirmed: !isConfirmed,
+            balance,
+            explorer: `${explorerBase}/tx/${txid}`,
+        });
+    }
+    catch (err) {
+        await wallet.destroy();
+        // Provide helpful error messages for common issues
+        if (err.message?.includes('already') || err.message?.includes('duplicate')) {
+            return fail(`UTXO ${txid}:${vout} appears to already be imported.`);
+        }
+        if (err.message?.includes('script') || err.message?.includes('locking')) {
+            return fail(`UTXO ${txid}:${vout} does not belong to this wallet's address. Make sure you sent to the correct address.`);
+        }
+        return fail(`Failed to import UTXO: ${err.message}`);
+    }
+}
+/**
+ * Refund command: sweep wallet to an address.
+ */
+export async function cmdRefund(targetAddress) {
+    if (!targetAddress) {
+        return fail('Usage: refund <address>');
+    }
+    if (!fs.existsSync(PATHS.walletIdentity)) {
+        return fail('Wallet not initialized. Run: setup');
+    }
+    // TODO IMPLEMENT THIS
+}

package/dist/scripts/wallet/identity.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Wallet identity helpers.
+ */
+import type { WalletIdentity } from '../types.js';
+/**
+ * Load wallet identity from disk.
+ * @returns Identity object with rootKeyHex and identityKey
+ * @throws Error if wallet not initialized
+ */
+export declare function loadWalletIdentity(): WalletIdentity;
+/**
+ * Load identity and private key for relay message signing.
+ * @returns Object with identityKey and privKey
+ */
+export declare function loadIdentity(): Promise<{
+    identityKey: string;
+    privKey: any;
+}>;
+/**
+ * Sign a relay message using ECDSA.
+ * @param privKey - Private key for signing
+ * @param to - Recipient's identity key
+ * @param type - Message type
+ * @param payload - Message payload
+ * @returns Hex-encoded DER signature
+ */
+export declare function signRelayMessage(privKey: any, to: string, type: string, payload: unknown): Promise<string>;
+/**
+ * Verify a relay message signature.
+ * @param fromKey - Sender's public key
+ * @param to - Recipient's identity key
+ * @param type - Message type
+ * @param payload - Message payload
+ * @param signatureHex - Hex-encoded DER signature
+ * @returns Verification result
+ */
+export declare function verifyRelaySignature(fromKey: string, to: string, type: string, payload: unknown, signatureHex: string | undefined): Promise<{
+    valid: boolean;
+    reason?: string;
+}>;
+/**
+ * Derive wallet address components from a private key.
+ *
+ * IMPORTANT: This uses BRC-29 key derivation to create a child key.
+ * Any transactions spending to this address MUST use the matching
+ * child private key for signing, NOT the root key.
+ *
+ * Use deriveWalletKeys() to get both the address and signing key.
+ */
+export declare function deriveWalletAddress(privKey: any): Promise<{
+    address: string;
+    hash160: Uint8Array;
+    pubKey: any;
+}>;
+/**
+ * Derive wallet keys for both address AND transaction signing.
+ *
+ * CRITICAL: Use this function to get the child private key for signing
+ * transactions that spend from the derived address. Do NOT use the
+ * root private key - it will cause signature verification failures!
+ *
+ * @param rootPrivKey - Root private key from wallet identity
+ * @returns Object with address, hash160, and CHILD private key for signing
+ */
+export declare function deriveWalletKeys(rootPrivKey: any): Promise<{
+    address: string;
+    hash160: Uint8Array;
+    pubKey: any;
+    childPrivKey: any;
+}>;