2020117-agent 0.4.4 → 0.4.6

package/dist/agent.js

@@ -743,6 +743,7 @@ async function startSwarmListener(label) {
                 lastPaidAt: Date.now(),
                 billingTimer: null,
                 timeoutTimer: null,
+                customerPubkey: msg.pubkey || undefined,
             };
             activeSessions.set(sessionId, session);
             node.send(socket, {
@@ -751,6 +752,7 @@ async function startSwarmListener(label) {
                 session_id: sessionId,
                 sats_per_minute: satsPerMinute,
                 payment_method: paymentMethod,
+                pubkey: state.sovereignKeys?.pubkey,
             });
             // Send first billing tick
             await sendBillingTick(node, session, billingAmount, label);
@@ -1035,6 +1037,32 @@ function endSession(node, session, label) {
         // Socket may already be closed (peer disconnect)
     }
     console.log(`[${label}] Session ${session.sessionId} ended: ${session.totalEarned} sats, ${durationS}s`);
+    // Publish Kind 30311 endorsement for customer (best-effort)
+    if (state.sovereignKeys && state.relayPool && session.customerPubkey) {
+        try {
+            const endorsement = signEvent({
+                kind: 30311,
+                tags: [
+                    ['d', session.customerPubkey],
+                    ['p', session.customerPubkey],
+                    ['rating', '5'],
+                    ['k', String(KIND)],
+                ],
+                content: JSON.stringify({
+                    rating: 5,
+                    context: {
+                        session_duration_s: durationS,
+                        total_sats: session.totalEarned,
+                        kinds: [KIND],
+                        last_job_at: Math.floor(Date.now() / 1000),
+                    },
+                }),
+            }, state.sovereignKeys.privkey);
+            state.relayPool.publish(endorsement).catch(() => { });
+            console.log(`[${label}] Published endorsement for customer ${session.customerPubkey.slice(0, 8)}`);
+        }
+        catch { }
+    }
     // Update P2P lifetime counters
     state.p2pSessionsCompleted++;
     state.p2pTotalEarnedSats += session.totalEarned;

package/dist/cashu.d.ts

@@ -45,6 +45,22 @@ export declare function decodeCashuToken(tokenStr: string): {
  * Encode proofs back into a portable token string.
  */
 export declare function encodeCashuToken(mintUrl: string, proofs: Proof[]): string;
+/**
+ * Melt proofs back into a Lightning invoice — converts Cashu back to Lightning.
+ * Returns the payment preimage and any change proofs.
+ */
+export declare function meltProofs(mintUrl: string, proofs: Proof[], invoice: string): Promise<{
+    preimage: string;
+    change: Proof[];
+}>;
+/**
+ * Estimate total cost to melt (invoice amount + fee_reserve) for a given invoice.
+ */
+export declare function estimateMeltFee(mintUrl: string, invoice: string): Promise<{
+    amount: number;
+    fee: number;
+    total: number;
+}>;
 /**
  * Request a mint quote — returns a Lightning invoice to pay for minting tokens.
  */

package/dist/cashu.js

@@ -60,6 +60,31 @@ export function decodeCashuToken(tokenStr) {
 export function encodeCashuToken(mintUrl, proofs) {
     return getEncodedTokenV4({ mint: mintUrl, proofs });
 }
+/**
+ * Melt proofs back into a Lightning invoice — converts Cashu back to Lightning.
+ * Returns the payment preimage and any change proofs.
+ */
+export async function meltProofs(mintUrl, proofs, invoice) {
+    const wallet = await getWallet(mintUrl);
+    const meltQuote = await wallet.createMeltQuote(invoice);
+    const amountNeeded = meltQuote.amount + meltQuote.fee_reserve;
+    const total = proofs.reduce((s, p) => s + p.amount, 0);
+    if (total < amountNeeded) {
+        throw new Error(`Need ${amountNeeded} sats (invoice ${meltQuote.amount} + fee ${meltQuote.fee_reserve}) but only have ${total}`);
+    }
+    const { send, keep } = await wallet.send(amountNeeded, proofs, { includeFees: true });
+    const result = await wallet.meltProofs(meltQuote, send);
+    const change = [...keep, ...(result.change || [])];
+    return { preimage: result.quote.payment_preimage || '', change };
+}
+/**
+ * Estimate total cost to melt (invoice amount + fee_reserve) for a given invoice.
+ */
+export async function estimateMeltFee(mintUrl, invoice) {
+    const wallet = await getWallet(mintUrl);
+    const quote = await wallet.createMeltQuote(invoice);
+    return { amount: quote.amount, fee: quote.fee_reserve, total: quote.amount + quote.fee_reserve };
+}
 /**
  * Request a mint quote — returns a Lightning invoice to pay for minting tokens.
  */

package/dist/session.js

@@ -51,9 +51,9 @@ for (const arg of process.argv.slice(2)) {
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { queryProviderSkill } from './p2p-customer.js';
 import { walletPayInvoice, walletGetBalance, hasApiKey } from './api.js';
-import { decodeCashuToken, sendCashuToken, createMintQuote, claimMintQuote } from './cashu.js';
-import { parseNwcUri, nwcGetBalance, nwcPayInvoice } from './nwc.js';
-import { loadSovereignKeys } from './nostr.js';
+import { decodeCashuToken, sendCashuToken, createMintQuote, claimMintQuote, meltProofs, estimateMeltFee } from './cashu.js';
+import { parseNwcUri, nwcGetBalance, nwcPayInvoice, nwcMakeInvoice } from './nwc.js';
+import { loadSovereignKeys, signEvent, RelayPool } from './nostr.js';
 import { randomBytes } from 'crypto';
 import { createServer } from 'http';
 import { createInterface } from 'readline';
@@ -65,11 +65,15 @@ const BUDGET = Number(process.env.BUDGET_SATS) || 500;
 const PORT = Number(process.env.SESSION_PORT) || 8080;
 const CASHU_TOKEN = process.env.CASHU_TOKEN || '';
 const MINT_URL = process.env.CASHU_MINT_URL || 'https://8333.space:3338';
+// Load sovereign keys (for pubkey exchange + endorsement publishing)
+const sovereignKeys = loadSovereignKeys(process.env.AGENT);
 // Load NWC URI: --nwc flag > .2020117_keys nwc_uri > none
 let nwcParsed = null;
 const nwcUri = process.env.NWC_URI
-    || loadSovereignKeys(process.env.AGENT)?.nwc_uri
+    || sovereignKeys?.nwc_uri
     || null;
+// Track provider's Nostr pubkey (received in session_ack)
+let providerPubkey = null;
 // Mutable Cashu wallet state (loaded from CASHU_TOKEN at startup)
 let cashuState = null;
 const TICK_INTERVAL_MS = 60_000;
@@ -694,6 +698,62 @@ async function endSession() {
         }
         log(`Session ended. Total: ${state.totalSpent} sats for ${duration}s.`);
     }
+    // Publish Kind 30311 endorsement for provider (best-effort)
+    if (sovereignKeys?.privkey && providerPubkey) {
+        try {
+            const endorsement = signEvent({
+                kind: 30311,
+                tags: [
+                    ['d', providerPubkey],
+                    ['p', providerPubkey],
+                    ['rating', '5'],
+                    ['k', String(KIND)],
+                ],
+                content: JSON.stringify({
+                    rating: 5,
+                    context: {
+                        session_duration_s: elapsedSeconds(),
+                        total_sats: state.totalSpent,
+                        kinds: [KIND],
+                        last_job_at: Math.floor(Date.now() / 1000),
+                    },
+                }),
+            }, sovereignKeys.privkey);
+            const relayUrls = sovereignKeys.relays?.length ? sovereignKeys.relays : ['wss://relay.2020117.xyz'];
+            const relay = new RelayPool(relayUrls);
+            await relay.connect();
+            await relay.publish(endorsement);
+            await relay.close();
+            log(`Published endorsement for provider ${providerPubkey.slice(0, 8)}`);
+        }
+        catch { }
+    }
+    // Refund remaining Cashu proofs back to NWC wallet
+    if (cashuState && cashuState.proofs.length > 0 && nwcParsed) {
+        const remaining = cashuState.proofs.reduce((s, p) => s + p.amount, 0);
+        if (remaining >= 3) {
+            log(`Refunding ${remaining} sats Cashu → NWC wallet...`);
+            try {
+                // Probe: create 1-sat invoice to discover melt fee_reserve + swap fee
+                const probe = await nwcMakeInvoice(nwcParsed, 1000, 'fee-probe');
+                const { fee } = await estimateMeltFee(cashuState.mintUrl, probe.bolt11);
+                // fee = melt fee_reserve; +1 for Cashu internal swap fee
+                const refundAmount = remaining - fee - 1;
+                if (refundAmount < 1) {
+                    warn(`Remaining ${remaining} sats < melt fee (${fee} sats), cannot refund`);
+                }
+                else {
+                    const { bolt11 } = await nwcMakeInvoice(nwcParsed, refundAmount * 1000, '2020117-session refund');
+                    const { preimage } = await meltProofs(cashuState.mintUrl, cashuState.proofs, bolt11);
+                    cashuState.proofs = [];
+                    log(`Refunded ${refundAmount} sats (fee: ${fee}, preimage: ${preimage?.slice(0, 16)}...)`);
+                }
+            }
+            catch (e) {
+                warn(`Refund failed: ${e.message} — ${remaining} sats lost`);
+            }
+        }
+    }
     // Close HTTP proxy
     if (state.httpServer) {
         state.httpServer.close();
@@ -774,36 +834,20 @@ async function main() {
         }
     }
     else if (nwcUri) {
-        // NWC direct: auto-mint Cashu tokens via local NWC wallet (no platform API)
+        // NWC direct: pay provider invoices via Lightning — no Cashu needed
         nwcParsed = parseNwcUri(nwcUri);
         const { balance_msats } = await nwcGetBalance(nwcParsed);
         const balance = Math.floor(balance_msats / 1000);
         if (balance <= 0) {
-            warn('NWC wallet balance is 0. Cannot auto-mint Cashu tokens.');
+            warn('NWC wallet balance is 0.');
             await node.destroy();
             process.exit(1);
         }
-        const mintAmount = Math.min(balance, BUDGET);
-        log(`NWC wallet balance: ${balance} sats — minting ${mintAmount} sats from ${MINT_URL}`);
-        try {
-            const { quote, invoice } = await createMintQuote(MINT_URL, mintAmount);
-            log(`Mint quote: ${quote} (invoice: ${invoice.slice(0, 30)}...)`);
-            log('Paying mint invoice via NWC...');
-            const { preimage } = await nwcPayInvoice(nwcParsed, invoice);
-            log(`Invoice paid (preimage: ${preimage?.slice(0, 16)}...)`);
-            log('Claiming minted tokens...');
-            const token = await claimMintQuote(MINT_URL, mintAmount, quote);
-            const { mint, proofs } = decodeCashuToken(token);
-            cashuState = { mintUrl: mint, proofs };
-            paymentMethod = 'cashu';
-            const totalMinted = proofs.reduce((s, p) => s + p.amount, 0);
-            log(`Minted ${totalMinted} sats Cashu token — using Cashu payment mode`);
-        }
-        catch (e) {
-            warn(`NWC auto-mint failed: ${e.message}`);
-            await node.destroy();
-            process.exit(1);
+        if (balance < BUDGET) {
+            warn(`NWC wallet balance (${balance} sats) < budget (${BUDGET} sats)`);
         }
+        paymentMethod = 'invoice';
+        log(`Payment: NWC direct (balance: ${balance} sats, pay-per-tick via Lightning)`);
     }
     else if (hasApiKey()) {
         // Platform API fallback: auto-mint Cashu tokens via platform wallet proxy
@@ -854,6 +898,7 @@ async function main() {
         budget: BUDGET,
         sats_per_minute: satsPerMinute,
         payment_method: paymentMethod,
+        pubkey: sovereignKeys?.pubkey,
     }, 15_000);
     if (ackResp.type !== 'session_ack' || !ackResp.session_id) {
         warn(`Unexpected response: ${ackResp.type}`);
@@ -862,11 +907,39 @@ async function main() {
     }
     state.sessionId = ackResp.session_id;
     state.startedAt = Date.now();
+    providerPubkey = ackResp.pubkey || null;
     // If the provider dictated a different rate, use it
     if (ackResp.sats_per_minute && ackResp.sats_per_minute !== satsPerMinute) {
         state.satsPerMinute = ackResp.sats_per_minute;
         log(`Provider adjusted rate: ${ackResp.sats_per_minute} sats/min`);
     }
+    // Provider may override payment method (e.g. no Lightning Address → force cashu)
+    if (ackResp.payment_method && ackResp.payment_method !== paymentMethod) {
+        if (ackResp.payment_method === 'cashu' && paymentMethod === 'invoice' && nwcParsed) {
+            // Provider doesn't support invoice — fall back to NWC-minted Cashu
+            log(`Provider requires Cashu — minting via NWC...`);
+            try {
+                const { balance_msats } = await nwcGetBalance(nwcParsed);
+                const balance = Math.floor(balance_msats / 1000);
+                const mintAmount = Math.min(balance, BUDGET);
+                const { quote, invoice } = await createMintQuote(MINT_URL, mintAmount);
+                const { preimage } = await nwcPayInvoice(nwcParsed, invoice);
+                const token = await claimMintQuote(MINT_URL, mintAmount, quote);
+                const { mint, proofs } = decodeCashuToken(token);
+                cashuState = { mintUrl: mint, proofs };
+                paymentMethod = 'cashu';
+                log(`Minted ${proofs.reduce((s, p) => s + p.amount, 0)} sats Cashu — fallback ready`);
+            }
+            catch (e) {
+                warn(`Cashu fallback mint failed: ${e.message}`);
+                await node.destroy();
+                process.exit(1);
+            }
+        }
+        else {
+            paymentMethod = ackResp.payment_method;
+        }
+    }
     log(`Session started: ${state.sessionId}`);
     log(`Billing: ${state.satsPerMinute} sats/min via ${paymentMethod}`);
     // 6. Start HTTP proxy

package/dist/swarm.d.ts

@@ -46,6 +46,7 @@ export interface SwarmMessage {
     balance?: number;
     duration_s?: number;
     payment_method?: 'cashu' | 'invoice';
+    pubkey?: string;
     bolt11?: string;
     preimage?: string;
     cashu_token?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "2020117-agent",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "2020117 agent runtime — API polling + Hyperswarm P2P + Sovereign Nostr mode + Cashu/Lightning payments",
   "type": "module",
   "bin": {