openclaw-overlay-plugin 0.7.22

package/dist/cli-main.js

@@ -0,0 +1,192 @@
+/**
+ * BSV Overlay CLI - Main Command Dispatcher
+ *
+ * Routes commands to the appropriate modules.
+ * All business logic is in the scripts/ modules.
+ */
+import { ok, fail } from './scripts/output.js';
+// Wallet commands
+import { cmdSetup, cmdIdentity, cmdAddress } from './scripts/wallet/setup.js';
+import { cmdBalance, cmdImport, cmdRefund } from './scripts/wallet/balance.js';
+// Overlay registration commands
+import { cmdRegister, cmdUnregister } from './scripts/overlay/registration.js';
+// Service commands
+import { cmdServices, cmdAdvertise, cmdRemove, cmdReadvertise } from './scripts/overlay/services.js';
+// Discovery commands
+import { cmdDiscover } from './scripts/overlay/discover.js';
+// Payment commands
+import { cmdPay, cmdVerify, cmdAccept } from './scripts/payment/commands.js';
+// Messaging commands
+import { cmdSend } from './scripts/messaging/send.js';
+import { cmdInbox, cmdAck } from './scripts/messaging/inbox.js';
+import { cmdPoll } from './scripts/messaging/poll.js';
+import { cmdConnect } from './scripts/messaging/connect.js';
+// Service request/response commands
+import { cmdRequestService } from './scripts/services/request.js';
+import { cmdRespondService, cmdResearchRespond } from './scripts/services/respond.js';
+import { cmdServiceQueue, cmdResearchQueue } from './scripts/services/queue.js';
+// X verification commands
+import { cmdXVerifyStart, cmdXVerifyComplete, cmdXVerifications, cmdXLookup, cmdXEngagementQueue, cmdXEngagementFulfill, } from './scripts/x-verification/commands.js';
+// Baemail commands
+import { cmdBaemailSetup, cmdBaemailConfig, cmdBaemailBlock, cmdBaemailUnblock, cmdBaemailLog, cmdBaemailRefund, } from './scripts/baemail/commands.js';
+const [, , command, ...args] = process.argv;
+async function main() {
+    try {
+        switch (command) {
+            // Help
+            case 'help':
+            case '--help':
+            case '-h':
+                ok({
+                    usage: 'openclaw-overlay <command> [args...]',
+                    commands: {
+                        wallet: ['setup', 'identity', 'address', 'balance', 'import <txid> [vout]', 'refund <address>'],
+                        registration: ['register', 'unregister'],
+                        services: ['services', 'advertise <id> <name> <priceSats> [desc]', 'readvertise <id> [name] [priceSats] [desc]', 'remove <id>'],
+                        discovery: ['discover [--service <type>] [--agent <name>]'],
+                        payments: ['pay <pubkey> <sats> [desc]', 'verify <beef>', 'accept <beef> <prefix> <suffix> <senderKey> [desc]'],
+                        messaging: ['send <key> <type> <json>', 'inbox', 'ack', 'poll', 'connect'],
+                        'service-requests': ['request-service <key> <serviceId> <sats> [input]', 'service-queue', 'respond-service <reqId> <key> <serviceId> <result>'],
+                        research: ['research-queue', 'research-respond <reqId>'],
+                        'x-verification': ['x-verify-start <handle>', 'x-verify-complete <handle>', 'x-verifications', 'x-lookup <handle>', 'x-engagement-queue', 'x-engagement-fulfill <reqId> <result>'],
+                        baemail: ['baemail-setup <price> <xHandle> <forwardEmail> <greeting>', 'baemail-config', 'baemail-block <sender>', 'baemail-unblock <sender>', 'baemail-log [limit]', 'baemail-refund <msgId>'],
+                    },
+                });
+                break;
+            // Wallet
+            case 'setup':
+                await cmdSetup();
+                break;
+            case 'identity':
+                await cmdIdentity();
+                break;
+            case 'address':
+                await cmdAddress();
+                break;
+            case 'balance':
+                await cmdBalance();
+                break;
+            case 'import':
+                await cmdImport(args[0], args[1]);
+                break;
+            case 'refund':
+                await cmdRefund(args[0]);
+                break;
+            // Overlay registration
+            case 'register':
+                await cmdRegister();
+                break;
+            case 'unregister':
+                await cmdUnregister();
+                break;
+            // Services
+            case 'services':
+                await cmdServices();
+                break;
+            case 'advertise':
+                await cmdAdvertise(args[0], args[1], args[2], args[3]);
+                break;
+            case 'remove':
+                await cmdRemove(args[0]);
+                break;
+            case 'readvertise':
+                await cmdReadvertise(args[0], args[1], args[2], args.slice(3).join(' ') || undefined);
+                break;
+            // Discovery
+            case 'discover':
+                await cmdDiscover(args);
+                break;
+            // Payments
+            case 'pay':
+                await cmdPay(args[0], args[1], args.slice(2).join(' ') || undefined);
+                break;
+            case 'verify':
+                await cmdVerify(args[0]);
+                break;
+            case 'accept':
+                await cmdAccept(args[0], args[1], args[2], args[3], args.slice(4).join(' ') || undefined);
+                break;
+            // Messaging (relay)
+            case 'send':
+                await cmdSend(args[0], args[1], args[2]);
+                break;
+            case 'inbox':
+                await cmdInbox(args);
+                break;
+            case 'ack':
+                await cmdAck(args);
+                break;
+            case 'poll':
+                await cmdPoll();
+                break;
+            case 'connect':
+                await cmdConnect();
+                break;
+            case 'request-service':
+                await cmdRequestService(args[0], args[1], args[2], args[3]);
+                break;
+            case 'research-respond':
+                await cmdResearchRespond(args[0]);
+                break;
+            case 'research-queue':
+                await cmdResearchQueue();
+                break;
+            case 'service-queue':
+                await cmdServiceQueue();
+                break;
+            case 'respond-service':
+                await cmdRespondService(args[0], args[1], args[2], args.slice(3).join(' '));
+                break;
+            // X Account Verification
+            case 'x-verify-start':
+                await cmdXVerifyStart(args[0]);
+                break;
+            case 'x-verify-complete':
+                await cmdXVerifyComplete(args[0]);
+                break;
+            case 'x-verifications':
+                await cmdXVerifications();
+                break;
+            case 'x-lookup':
+                await cmdXLookup(args[0]);
+                break;
+            // X Engagement Service
+            case 'x-engagement-queue':
+                await cmdXEngagementQueue();
+                break;
+            case 'x-engagement-fulfill':
+                await cmdXEngagementFulfill(args[0], args[1]);
+                break;
+            // Baemail Service
+            case 'baemail-setup':
+                await cmdBaemailSetup(args[0], args[1], args[2], args[3]);
+                break;
+            case 'baemail-config':
+                await cmdBaemailConfig();
+                break;
+            case 'baemail-block':
+                await cmdBaemailBlock(args[0]);
+                break;
+            case 'baemail-unblock':
+                await cmdBaemailUnblock(args[0]);
+                break;
+            case 'baemail-log':
+                await cmdBaemailLog(args[0]);
+                break;
+            case 'baemail-refund':
+                await cmdBaemailRefund(args[0]);
+                break;
+            default:
+                fail(`Unknown command: ${command || '(none)'}. Commands: setup, identity, address, balance, import, refund, ` +
+                    `register, unregister, services, advertise, readvertise, remove, discover, pay, verify, accept, ` +
+                    `send, inbox, ack, poll, connect, request-service, research-queue, research-respond, ` +
+                    `service-queue, respond-service, x-verify-start, x-verify-complete, x-verifications, x-lookup, ` +
+                    `x-engagement-queue, x-engagement-fulfill, baemail-setup, baemail-config, baemail-block, ` +
+                    `baemail-unblock, baemail-log, baemail-refund`);
+        }
+    }
+    catch (err) {
+        fail(err.message || String(err));
+    }
+}
+main();

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * BSV Overlay CLI - Bootstrap Entry Point
+ *
+ * Sets environment variables before importing the main CLI module
+ * to suppress dotenv v17 verbose logging.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * BSV Overlay CLI - Bootstrap Entry Point
+ *
+ * Sets environment variables before importing the main CLI module
+ * to suppress dotenv v17 verbose logging.
+ */
+// Must be set before any imports that might load dotenv
+process.env.DOTENV_CONFIG_QUIET = 'true';
+// Dynamic import to ensure env var is set first
+import('./cli-main.js');
+// Before importing the library
+globalThis.window = { fetch: globalThis.fetch };
+export {};

package/dist/core/config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @a2a-bsv/core — Configuration defaults and helpers.
+ */
+import type { WalletConfig } from './types.js';
+/** Map our 'mainnet'/'testnet' to the wallet-toolbox's 'main'/'test' chain type. */
+export type Chain = 'main' | 'test';
+export declare function toChain(network: WalletConfig['network']): Chain;
+/** Default TAAL API keys from the wallet-toolbox examples. */
+export declare const DEFAULT_TAAL_API_KEYS: Record<Chain, string>;
+/** Default SQLite database name. */
+export declare const DEFAULT_DB_NAME = "a2a_agent_wallet";

package/dist/core/config.js

@@ -0,0 +1,13 @@
+/**
+ * @a2a-bsv/core — Configuration defaults and helpers.
+ */
+export function toChain(network) {
+    return network === 'mainnet' ? 'main' : 'test';
+}
+/** Default TAAL API keys from the wallet-toolbox examples. */
+export const DEFAULT_TAAL_API_KEYS = {
+    main: 'mainnet_9596de07e92300c6287e4393594ae39c',
+    test: 'testnet_0e6cf72133b43ea2d7861da2a38684e3',
+};
+/** Default SQLite database name. */
+export const DEFAULT_DB_NAME = 'a2a_agent_wallet';

package/dist/core/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @a2a-bsv/core — Agent-to-agent BSV payment library.
+ *
+ * Wraps @bsv/sdk and @bsv/wallet-toolbox to provide a clean, minimal API
+ * for AI agents to pay each other using BSV blockchain transactions.
+ *
+ * @example
+ * ```ts
+ * import { BSVAgentWallet } from '@a2a-bsv/core';
+ *
+ * const wallet = await BSVAgentWallet.load({
+ *   network: 'testnet',
+ *   storageDir: './my-agent-wallet',
+ * });
+ *
+ * const identityKey = await wallet.getIdentityKey();
+ * console.log('My identity:', identityKey);
+ * ```
+ */
+export { BSVAgentWallet } from './wallet.js';
+export type { WalletConfig, WalletIdentity, PaymentParams, PaymentResult, VerifyParams, VerifyResult, AcceptParams, AcceptResult, } from './types.js';
+export { toChain, DEFAULT_TAAL_API_KEYS, DEFAULT_DB_NAME } from './config.js';
+export type { Chain } from './config.js';
+export { buildPayment } from './payment.js';
+export { verifyPayment, acceptPayment } from './verify.js';

package/dist/core/index.js

@@ -0,0 +1,26 @@
+/**
+ * @a2a-bsv/core — Agent-to-agent BSV payment library.
+ *
+ * Wraps @bsv/sdk and @bsv/wallet-toolbox to provide a clean, minimal API
+ * for AI agents to pay each other using BSV blockchain transactions.
+ *
+ * @example
+ * ```ts
+ * import { BSVAgentWallet } from '@a2a-bsv/core';
+ *
+ * const wallet = await BSVAgentWallet.load({
+ *   network: 'testnet',
+ *   storageDir: './my-agent-wallet',
+ * });
+ *
+ * const identityKey = await wallet.getIdentityKey();
+ * console.log('My identity:', identityKey);
+ * ```
+ */
+// Main wallet class
+export { BSVAgentWallet } from './wallet.js';
+// Config helpers (for advanced use)
+export { toChain, DEFAULT_TAAL_API_KEYS, DEFAULT_DB_NAME } from './config.js';
+// Lower-level helpers (for advanced use)
+export { buildPayment } from './payment.js';
+export { verifyPayment, acceptPayment } from './verify.js';

package/dist/core/payment.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @a2a-bsv/core — Payment construction helpers.
+ *
+ * Uses BRC-29 key derivation so the recipient can internalize the payment
+ * without ever reusing an address.
+ */
+import type { SetupWallet } from '@bsv/wallet-toolbox';
+import type { PaymentParams, PaymentResult } from './types.js';
+/**
+ * Build a BRC-29 payment transaction using the wallet's createAction API.
+ *
+ * The transaction is created with `acceptDelayedBroadcast: false` — the sender
+ * broadcasts immediately. The resulting Atomic BEEF and derivation metadata are
+ * returned so the recipient can verify and internalize the payment on their side.
+ */
+export declare function buildPayment(setup: SetupWallet, params: PaymentParams): Promise<PaymentResult>;

package/dist/core/payment.js

@@ -0,0 +1,94 @@
+/**
+ * @a2a-bsv/core — Payment construction helpers.
+ *
+ * Uses BRC-29 key derivation so the recipient can internalize the payment
+ * without ever reusing an address.
+ */
+import { Beef, Utils } from '@bsv/sdk';
+import { randomBytesBase64, ScriptTemplateBRC29 } from '@bsv/wallet-toolbox';
+/**
+ * Build a BRC-29 payment transaction using the wallet's createAction API.
+ *
+ * The transaction is created with `acceptDelayedBroadcast: false` — the sender
+ * broadcasts immediately. The resulting Atomic BEEF and derivation metadata are
+ * returned so the recipient can verify and internalize the payment on their side.
+ */
+export async function buildPayment(setup, params) {
+    const { to, satoshis, description } = params;
+    const desc = normalizeDescription(description ?? 'agent payment');
+    // Generate unique BRC-29 derivation prefixes and suffixes
+    const derivationPrefix = randomBytesBase64(8);
+    const derivationSuffix = randomBytesBase64(8);
+    // Build BRC-29 locking script
+    const keyDeriver = setup.keyDeriver;
+    const t = new ScriptTemplateBRC29({
+        derivationPrefix,
+        derivationSuffix,
+        keyDeriver,
+    });
+    // Determine the recipient identity key.
+    // If `to` is a compressed public key hex (66 chars, starts with 02/03), use directly.
+    // Otherwise treat as an address — for BRC-29 we need a public key.
+    let recipientPubKey;
+    if (/^0[23][0-9a-fA-F]{64}$/.test(to)) {
+        recipientPubKey = to;
+    }
+    else {
+        // If it's an address, we can't do BRC-29 (needs pubkey). Throw a clear error.
+        throw new Error('PaymentParams.to must be a compressed public key (hex) for BRC-29 payments. ' +
+            'Raw BSV addresses are not supported — the recipient must share their identity key.');
+    }
+    const lockingScript = t.lock(setup.rootKey.toString(), recipientPubKey);
+    const label = 'a2a-payment';
+    const car = await setup.wallet.createAction({
+        outputs: [
+            {
+                lockingScript: lockingScript.toHex(),
+                satoshis,
+                outputDescription: desc,
+                tags: ['relinquish'],
+                customInstructions: JSON.stringify({
+                    derivationPrefix,
+                    derivationSuffix,
+                    type: 'BRC29',
+                }),
+            },
+        ],
+        options: {
+            randomizeOutputs: false,
+            acceptDelayedBroadcast: false,
+        },
+        labels: [label],
+        description: desc,
+    });
+    // Extract the txid from the createAction result.
+    // The tx field is a number[] (AtomicBEEF binary). Parse it to get txid.
+    if (!car.tx) {
+        throw new Error('createAction did not return a transaction. Check wallet funding.');
+    }
+    const beef = Beef.fromBinary(car.tx);
+    // The last transaction in the beef is our new tx
+    const lastTx = beef.txs[beef.txs.length - 1];
+    const txid = lastTx.txid;
+    // Encode the atomic BEEF as base64
+    const atomicBinary = beef.toBinaryAtomic(txid);
+    const beefBase64 = Utils.toBase64(atomicBinary);
+    return {
+        beef: beefBase64,
+        txid,
+        satoshis,
+        derivationPrefix,
+        derivationSuffix,
+        senderIdentityKey: setup.identityKey,
+    };
+}
+/**
+ * Ensure description meets BRC-100's 5-50 character requirement.
+ */
+function normalizeDescription(desc) {
+    if (desc.length < 5)
+        return desc.padEnd(5, ' ');
+    if (desc.length > 50)
+        return desc.slice(0, 50);
+    return desc;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @a2a-bsv/core — Type definitions for agent-to-agent BSV payments.
+ */
+/** Wallet configuration for creating or loading an agent wallet. */
+export interface WalletConfig {
+    /** BSV network to use. */
+    network: 'mainnet' | 'testnet';
+    /** Directory path for SQLite wallet persistence. */
+    storageDir: string;
+    /** Optional: pre-existing root private key hex. If omitted on create(), a new one is generated. */
+    rootKeyHex?: string;
+    /** Optional TAAL API key for ARC broadcasting. Falls back to public default. */
+    taalApiKey?: string;
+    /** Optional fee model in sat/KB. Falls back to BSV_FEE_MODEL env var or default 100 sat/KB. */
+    feeModel?: number;
+}
+/** Parameters for building a payment transaction. */
+export interface PaymentParams {
+    /** Recipient's compressed public key (hex) or BSV address. */
+    to: string;
+    /** Amount to pay in satoshis. */
+    satoshis: number;
+    /** Human-readable description (5-50 chars per BRC-100). */
+    description?: string;
+    /** Optional metadata embedded as OP_RETURN (future use). */
+    metadata?: {
+        taskId?: string;
+        protocol?: string;
+    };
+}
+/** Result from building a payment. */
+export interface PaymentResult {
+    /** Base64-encoded Atomic BEEF transaction data. */
+    beef: string;
+    /** Transaction ID (hex). */
+    txid: string;
+    /** Amount paid in satoshis. */
+    satoshis: number;
+    /** BRC-29 derivation prefix (base64). Needed by recipient to internalize. */
+    derivationPrefix: string;
+    /** BRC-29 derivation suffix (base64). Needed by recipient to internalize. */
+    derivationSuffix: string;
+    /** Sender's identity key (compressed hex). Needed by recipient to internalize. */
+    senderIdentityKey: string;
+}
+/** Parameters for verifying an incoming payment. */
+export interface VerifyParams {
+    /** Base64-encoded Atomic BEEF data. */
+    beef: string;
+    /** Expected payment amount in satoshis. */
+    expectedAmount?: number;
+    /** Expected sender identity key (optional). */
+    expectedSender?: string;
+}
+/** Result from verifying a payment. */
+export interface VerifyResult {
+    /** Whether the payment passes all checks. */
+    valid: boolean;
+    /** Transaction ID (hex). */
+    txid: string;
+    /** Number of outputs found in the transaction. */
+    outputCount: number;
+    /** Errors encountered during verification. */
+    errors: string[];
+}
+/** Parameters for accepting (internalizing) a verified payment. */
+export interface AcceptParams {
+    /** Base64-encoded Atomic BEEF data. */
+    beef: string;
+    /** The output index to internalize (default: 0). */
+    vout?: number;
+    /** BRC-29 derivation prefix from the PaymentResult. */
+    derivationPrefix: string;
+    /** BRC-29 derivation suffix from the PaymentResult. */
+    derivationSuffix: string;
+    /** Sender's identity key from the PaymentResult. */
+    senderIdentityKey: string;
+    /** Human-readable description for wallet records (5-50 chars). */
+    description?: string;
+}
+/** Result from accepting a payment. */
+export interface AcceptResult {
+    /** Whether the payment was accepted. */
+    accepted: boolean;
+}
+/** Serializable wallet identity info, persisted alongside the SQLite database. */
+export interface WalletIdentity {
+    /** The root private key (hex). Guard this carefully. */
+    rootKeyHex: string;
+    /** The wallet's public identity key (compressed hex). */
+    identityKey: string;
+    /** Network this wallet targets. */
+    network: 'mainnet' | 'testnet';
+}

package/dist/core/types.js

@@ -0,0 +1,4 @@
+/**
+ * @a2a-bsv/core — Type definitions for agent-to-agent BSV payments.
+ */
+export {};

package/dist/core/verify.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @a2a-bsv/core — Payment verification and acceptance helpers.
+ *
+ * Verification: parse the Atomic BEEF, validate structure.
+ * Acceptance: internalize the payment into the recipient wallet via BRC-29
+ * wallet payment protocol.
+ */
+import type { SetupWallet } from '@bsv/wallet-toolbox';
+import type { VerifyParams, VerifyResult, AcceptParams, AcceptResult } from './types.js';
+/**
+ * Verify an incoming Atomic BEEF payment.
+ *
+ * This performs structural validation:
+ * - Decodes the base64 BEEF
+ * - Checks the BEEF is parseable
+ * - Checks there is at least one transaction
+ * - Runs SPV verification via tx.verify()
+ * - Optionally checks the sender identity key
+ */
+export declare function verifyPayment(params: VerifyParams): Promise<VerifyResult>;
+/**
+ * Accept (internalize) a verified BRC-29 payment into the recipient's wallet.
+ *
+ * This calls wallet.internalizeAction with the 'wallet payment' protocol,
+ * providing the BRC-29 derivation info so the wallet can derive the correct
+ * key and claim the output.
+ */
+export declare function acceptPayment(setup: SetupWallet, params: AcceptParams): Promise<AcceptResult>;

package/dist/core/verify.js

@@ -0,0 +1,104 @@
+/**
+ * @a2a-bsv/core — Payment verification and acceptance helpers.
+ *
+ * Verification: parse the Atomic BEEF, validate structure.
+ * Acceptance: internalize the payment into the recipient wallet via BRC-29
+ * wallet payment protocol.
+ */
+import { Beef, Utils } from '@bsv/sdk';
+/**
+ * Verify an incoming Atomic BEEF payment.
+ *
+ * This performs structural validation:
+ * - Decodes the base64 BEEF
+ * - Checks the BEEF is parseable
+ * - Checks there is at least one transaction
+ * - Runs SPV verification via tx.verify()
+ * - Optionally checks the sender identity key
+ */
+export async function verifyPayment(params) {
+    const errors = [];
+    let txid = '';
+    let outputCount = 0;
+    try {
+        const binary = Utils.toArray(params.beef, 'base64');
+        const beef = Beef.fromBinary(binary);
+        if (beef.txs.length === 0) {
+            errors.push('BEEF contains no transactions');
+        }
+        else {
+            const lastTx = beef.txs[beef.txs.length - 1];
+            txid = lastTx.txid;
+            // Parse the atomic transaction to count outputs
+            const tx = beef.findAtomicTransaction(txid);
+            if (tx) {
+                outputCount = tx.outputs.length;
+                // Run SPV verification
+                try {
+                    await tx.verify();
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    errors.push(`SPV verification failed: ${message}`);
+                }
+            }
+            else {
+                errors.push('Could not find atomic transaction in BEEF');
+            }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        errors.push(`BEEF parse error: ${message}`);
+    }
+    // Sender validation is independent of BEEF parsing
+    if (params.expectedSender) {
+        if (!/^0[23][0-9a-fA-F]{64}$/.test(params.expectedSender)) {
+            errors.push('expectedSender is not a valid compressed public key');
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        txid,
+        outputCount,
+        errors,
+    };
+}
+/**
+ * Accept (internalize) a verified BRC-29 payment into the recipient's wallet.
+ *
+ * This calls wallet.internalizeAction with the 'wallet payment' protocol,
+ * providing the BRC-29 derivation info so the wallet can derive the correct
+ * key and claim the output.
+ */
+export async function acceptPayment(setup, params) {
+    const desc = normalizeDescription(params.description ?? 'received payment');
+    const vout = params.vout ?? 0;
+    const binary = Utils.toArray(params.beef, 'base64');
+    const args = {
+        tx: binary,
+        outputs: [
+            {
+                outputIndex: vout,
+                protocol: 'wallet payment',
+                paymentRemittance: {
+                    derivationPrefix: params.derivationPrefix,
+                    derivationSuffix: params.derivationSuffix,
+                    senderIdentityKey: params.senderIdentityKey,
+                },
+            },
+        ],
+        description: desc,
+    };
+    const result = await setup.wallet.internalizeAction(args);
+    return {
+        accepted: result.accepted,
+    };
+}
+function normalizeDescription(desc) {
+    if (desc.length < 5)
+        return desc.padEnd(5, ' ');
+    if (desc.length > 50)
+        return desc.slice(0, 50);
+    return desc;
+}