2020117-agent 0.3.2 → 0.3.4

package/dist/agent.js

@@ -69,7 +69,7 @@ import { randomBytes } from 'crypto';
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { createProcessor } from './processor.js';
 import { hasApiKey, loadAgentName, registerService, startHeartbeatLoop, getInbox, acceptJob, sendFeedback, submitResult, createJob, getJob, getProfile, reportSession, } from './api.js';
-import { initClinkAgent, collectPayment } from './clink.js';
+import { generateInvoice } from './clink.js';
 import { readFileSync } from 'fs';
 import WebSocket from 'ws';
 // Polyfill global WebSocket for Node.js < 22 (needed by @shocknet/clink-sdk)
@@ -161,12 +161,7 @@ async function main() {
             console.log(`[${label}] Lightning Address loaded from platform: ${LIGHTNING_ADDRESS}`);
         }
     }
-    // 3. Initialize CLINK agent identity (for P2P session debit)
-    if (LIGHTNING_ADDRESS) {
-        const { pubkey } = initClinkAgent();
-        console.log(`[${label}] CLINK: ${LIGHTNING_ADDRESS} (agent pubkey: ${pubkey.slice(0, 16)}...)`);
-    }
-    // 4. Platform registration + heartbeat
+    // 3. Platform registration + heartbeat
     await setupPlatform(label);
     // 5. Async inbox poller
     startInboxPoller(label);
@@ -341,10 +336,6 @@ async function startSwarmListener(label) {
                 node.send(socket, { type: 'error', id: msg.id, message: 'Provider has no Lightning Address configured' });
                 return;
             }
-            if (!msg.ndebit) {
-                node.send(socket, { type: 'error', id: msg.id, message: 'session_start requires ndebit authorization' });
-                return;
-            }
             const satsPerMinute = state.skill?.pricing?.sats_per_minute
                 || Number(process.env.SATS_PER_MINUTE)
                 || msg.sats_per_minute
@@ -358,7 +349,6 @@ async function startSwarmListener(label) {
                 peerId,
                 sessionId,
                 satsPerMinute,
-                ndebit: msg.ndebit,
                 totalEarned: 0,
                 startedAt: Date.now(),
                 lastDebitAt: Date.now(),
@@ -366,61 +356,67 @@ async function startSwarmListener(label) {
                 timeoutTimer: null,
             };
             activeSessions.set(sessionId, session);
-            // Debit first 10 minutes immediately (prepaid model)
-            const firstDebit = await collectPayment({
-                ndebit: session.ndebit,
-                lightningAddress: LIGHTNING_ADDRESS,
-                amountSats: debitAmount,
-            });
-            if (!firstDebit.ok) {
-                console.warn(`[${label}] Session ${sessionId}: first debit failed: ${firstDebit.error}`);
-                node.send(socket, { type: 'error', id: msg.id, message: `Payment failed: ${firstDebit.error}` });
+            // Generate first invoice and send to customer for payment
+            let firstInvoice;
+            try {
+                firstInvoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
+            }
+            catch (e) {
+                console.warn(`[${label}] Session ${sessionId}: invoice error: ${e.message}`);
+                node.send(socket, { type: 'error', id: msg.id, message: `Invoice error: ${e.message}` });
                 activeSessions.delete(sessionId);
                 return;
             }
-            session.totalEarned += debitAmount;
-            session.lastDebitAt = Date.now();
-            console.log(`[${label}] Session ${sessionId}: first ${BILLING_INTERVAL_MIN}min paid (${debitAmount} sats)`);
+            // Accept session first, then request payment
             node.send(socket, {
                 type: 'session_ack',
                 id: msg.id,
                 session_id: sessionId,
                 sats_per_minute: satsPerMinute,
             });
-            // Notify customer of the debit
+            // Send invoice to customer — wait for session_tick_ack with preimage
+            const tickId = randomBytes(4).toString('hex');
             node.send(socket, {
-                type: 'session_tick_ack',
-                id: sessionId,
+                type: 'session_tick',
+                id: tickId,
                 session_id: sessionId,
+                bolt11: firstInvoice,
                 amount: debitAmount,
-                balance: msg.budget ? msg.budget - session.totalEarned : undefined,
             });
-            // Debit every 10 minutes
+            console.log(`[${label}] Session ${sessionId}: waiting for first payment (${debitAmount} sats)`);
+            // Billing every 10 minutes — send invoice, wait for customer to pay
             session.debitTimer = setInterval(async () => {
-                const debit = await collectPayment({
-                    ndebit: session.ndebit,
-                    lightningAddress: LIGHTNING_ADDRESS,
-                    amountSats: debitAmount,
-                });
-                if (!debit.ok) {
-                    console.log(`[${label}] Session ${sessionId}: debit failed (${debit.error}) — ending session`);
+                let invoice;
+                try {
+                    invoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
+                }
+                catch (e) {
+                    console.log(`[${label}] Session ${sessionId}: invoice error (${e.message}) — ending session`);
                     endSession(node, session, label);
                     return;
                 }
-                session.totalEarned += debitAmount;
-                session.lastDebitAt = Date.now();
-                console.log(`[${label}] Session ${sessionId}: debit OK (+${debitAmount}, total: ${session.totalEarned} sats)`);
-                // Notify customer
+                const tid = randomBytes(4).toString('hex');
                 node.send(socket, {
-                    type: 'session_tick_ack',
-                    id: sessionId,
+                    type: 'session_tick',
+                    id: tid,
                     session_id: sessionId,
+                    bolt11: invoice,
                     amount: debitAmount,
-                    balance: msg.budget ? msg.budget - session.totalEarned : undefined,
                 });
+                console.log(`[${label}] Session ${sessionId}: sent invoice for ${debitAmount} sats`);
             }, BILLING_INTERVAL_MIN * 60_000);
             return;
         }
+        if (msg.type === 'session_tick_ack') {
+            const session = activeSessions.get(msg.session_id || '');
+            if (!session)
+                return;
+            const amount = msg.amount || 0;
+            session.totalEarned += amount;
+            session.lastDebitAt = Date.now();
+            console.log(`[${label}] Session ${session.sessionId}: payment received (+${amount}, total: ${session.totalEarned} sats)`);
+            return;
+        }
         if (msg.type === 'session_end') {
             const session = activeSessions.get(msg.session_id || '');
             if (!session)

package/dist/api.d.ts

@@ -92,6 +92,13 @@ export declare function updateProfile(fields: {
     about?: string;
     lightning_address?: string;
 }): Promise<boolean>;
+export declare function walletPayInvoice(bolt11: string): Promise<{
+    ok: boolean;
+    preimage?: string;
+    amount_sats?: number;
+    error?: string;
+}>;
+export declare function walletGetBalance(): Promise<number>;
 export interface ProxyDebitResult {
     ok: boolean;
     preimage?: string;

package/dist/api.js

@@ -298,6 +298,29 @@ export async function updateProfile(fields) {
     const result = await apiPut('/api/me', fields);
     return result !== null;
 }
+// --- Wallet API (built-in Lightning wallet) ---
+export async function walletPayInvoice(bolt11) {
+    if (!API_KEY)
+        return { ok: false, error: 'No API key' };
+    try {
+        const resp = await fetch(`${BASE_URL}/api/wallet/send`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${API_KEY}` },
+            body: JSON.stringify({ bolt11 }),
+        });
+        const data = await resp.json();
+        if (!resp.ok)
+            return { ok: false, error: data.error || `HTTP ${resp.status}` };
+        return { ok: true, preimage: data.preimage, amount_sats: data.amount_sats };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+export async function walletGetBalance() {
+    const data = await apiGet('/api/wallet/balance');
+    return data?.balance_sats ?? 0;
+}
 export async function proxyDebit(opts) {
     return apiPost('/api/dvm/proxy-debit', {
         ndebit: opts.ndebit,

package/dist/session.d.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 /**
  * P2P Session Client — "rent" a provider's service over Hyperswarm with
- * per-minute CLINK debit payments.
+ * per-minute wallet payments.
  *
  * Features:
- *   - Provider pulls per-minute payments via CLINK debit (ndebit authorization)
+ *   - Customer pays provider's invoices via built-in wallet
  *   - HTTP proxy server for browser-based access to provider APIs
  *   - Interactive CLI REPL (generate, status, skill, help, quit)
  *

package/dist/session.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 /**
  * P2P Session Client — "rent" a provider's service over Hyperswarm with
- * per-minute CLINK debit payments.
+ * per-minute wallet payments.
  *
  * Features:
- *   - Provider pulls per-minute payments via CLINK debit (ndebit authorization)
+ *   - Customer pays provider's invoices via built-in wallet
  *   - HTTP proxy server for browser-based access to provider APIs
  *   - Interactive CLI REPL (generate, status, skill, help, quit)
  *
@@ -39,25 +39,21 @@ for (const arg of process.argv.slice(2)) {
             break;
         case '--ndebit':
             process.env.CLINK_NDEBIT = val;
-            break;
+            break; // legacy, ignored
     }
 }
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { queryProviderSkill } from './p2p-customer.js';
-import { loadNdebit } from './api.js';
+import { walletPayInvoice, walletGetBalance } from './api.js';
 import { randomBytes } from 'crypto';
 import { createServer } from 'http';
 import { createInterface } from 'readline';
 import { mkdirSync, writeFileSync } from 'fs';
 import { WebSocketServer, WebSocket as WsWebSocket } from 'ws';
-// Polyfill global WebSocket for Node.js < 22 (needed by @shocknet/clink-sdk)
-if (!globalThis.WebSocket)
-    globalThis.WebSocket = WsWebSocket;
 // --- Config ---
 const KIND = Number(process.env.DVM_KIND) || 5200;
 const BUDGET = Number(process.env.BUDGET_SATS) || 500;
 const PORT = Number(process.env.SESSION_PORT) || 8080;
-const NDEBIT = process.env.CLINK_NDEBIT || loadNdebit() || '';
 const TICK_INTERVAL_MS = 60_000;
 const HTTP_TIMEOUT_MS = 60_000;
 const state = {
@@ -112,7 +108,7 @@ function sendAndWait(msg, timeoutMs) {
 }
 // --- 6. Message handler ---
 function setupMessageHandler() {
-    state.node.on('message', (msg) => {
+    state.node.on('message', async (msg) => {
         // Handle chunked HTTP responses — reassemble before resolving
         if (msg.type === 'http_response' && msg.chunk_total && msg.chunk_total > 1) {
             const id = msg.id;
@@ -162,8 +158,37 @@ function setupMessageHandler() {
                 cleanup();
                 break;
             }
+            case 'session_tick': {
+                // Provider sent an invoice for the next billing period — pay it
+                if (msg.bolt11 && msg.amount !== undefined) {
+                    const amount = msg.amount;
+                    if (state.totalSpent + amount > BUDGET) {
+                        log(`Budget exhausted (need ${amount}, remaining ${remainingSats()}) — ending session`);
+                        endSession();
+                        break;
+                    }
+                    log(`Paying invoice: ${amount} sats...`);
+                    const payResult = await walletPayInvoice(msg.bolt11);
+                    if (payResult.ok) {
+                        state.totalSpent += amount;
+                        log(`Paid ${amount} sats (total: ${state.totalSpent}, ~${estimatedMinutesLeft()} min left)`);
+                        state.node.send(state.socket, {
+                            type: 'session_tick_ack',
+                            id: msg.id,
+                            session_id: state.sessionId,
+                            preimage: payResult.preimage,
+                            amount,
+                        });
+                    }
+                    else {
+                        warn(`Payment failed: ${payResult.error} — ending session`);
+                        endSession();
+                    }
+                }
+                break;
+            }
             case 'session_tick_ack': {
-                // Provider debited our wallet and is reporting the result
+                // Legacy: provider-pull model notification (backward compat)
                 if (msg.amount !== undefined) {
                     state.totalSpent += msg.amount;
                 }
@@ -638,22 +663,20 @@ async function main() {
     state.satsPerMinute = satsPerMinute;
     log(`Pricing: ${satsPerMinute} sats/min`);
     log(`Budget: ${BUDGET} sats (~${Math.floor(BUDGET / satsPerMinute)} min)`);
-    // 4. Verify CLINK ndebit authorization
-    if (!NDEBIT) {
-        warn('No ndebit authorization. Provide --ndebit=ndebit1... or set CLINK_NDEBIT env var.');
-        warn('Get your ndebit from your CLINK-compatible wallet (e.g. ShockWallet → Connections).');
-        await node.destroy();
-        process.exit(1);
+    // 4. Check wallet balance
+    const balance = await walletGetBalance();
+    if (balance < BUDGET) {
+        warn(`Wallet balance (${balance} sats) is less than budget (${BUDGET} sats).`);
+        warn(`Fund your wallet: curl -X POST ${process.env.API_2020117_URL || 'https://2020117.xyz'}/api/wallet/invoice -H "Authorization: Bearer ..." -d '{"amount_sats":${BUDGET}}'`);
     }
-    log(`Payment: CLINK debit (provider pulls per-minute)`);
-    // 5. Send session_start with ndebit, wait for session_ack
+    log(`Wallet balance: ${balance} sats`);
+    // 5. Send session_start, wait for session_ack
     const startId = randomBytes(4).toString('hex');
     const ackResp = await sendAndWait({
         type: 'session_start',
         id: startId,
         budget: BUDGET,
         sats_per_minute: satsPerMinute,
-        ndebit: NDEBIT,
     }, 15_000);
     if (ackResp.type !== 'session_ack' || !ackResp.session_id) {
         warn(`Unexpected response: ${ackResp.type}`);
@@ -668,7 +691,7 @@ async function main() {
         log(`Provider adjusted rate: ${ackResp.sats_per_minute} sats/min`);
     }
     log(`Session started: ${state.sessionId}`);
-    log(`Provider will debit ${state.satsPerMinute} sats/min via CLINK`);
+    log(`Billing: ${state.satsPerMinute} sats/min (wallet → provider invoice)`);
     // 6. Start HTTP proxy
     try {
         await startHttpProxy();

package/dist/swarm.d.ts

@@ -46,6 +46,8 @@ export interface SwarmMessage {
     balance?: number;
     duration_s?: number;
     ndebit?: string;
+    bolt11?: string;
+    preimage?: string;
     method?: string;
     path?: string;
     headers?: Record<string, string>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "2020117-agent",
-  "version": "0.3.2",
-  "description": "2020117 agent runtime — API polling + Hyperswarm P2P + CLINK Lightning payments",
+  "version": "0.3.4",
+  "description": "2020117 agent runtime — API polling + Hyperswarm P2P + wallet Lightning payments",
   "type": "module",
   "bin": {
     "2020117-agent": "./dist/agent.js",