nostr-cln-events

nostr-events.js (7424B)

---

 #!/usr/bin/env node
 
 import {RelayPool, signId, calculateId, getPublicKey} from 'nostr'
 import Plugin from 'clightningjs'
 const plugin = new Plugin()
 let broadcast
 
 let forwarded = {}
 
 async function send_msg(pool, privkey, pubkey, {content, tags})
 {
 	const kind = 1
 	const created_at = Math.floor(Date.now()/1000)
 
 	let ev = {pubkey, kind, created_at, content, tags: tags || []}
 
 	ev.id = await calculateId(ev)
 	ev.sig = await signId(privkey, ev.id)
 
 	pool.send(["EVENT", ev])
 }
 
 async function process_forwards(pool, privkey, pubkey)
 {
 	const stats = Object.keys(forwarded).map(f => {
 		return `${f}: ${forwarded[f]}`
 	}).join("\n")
 	const content = "Forward stats:\n\n" + stats
 	await send_msg(pool, privkey, pubkey, {content})
 }
 
 // process forward notifications every 8 hours
 //setInterval(process_forwards, 1000 * 60 * 60 * 8)
 
 let channel_peers = {}
 
 async function gather_peer_info() {
 	const {peers} = await plugin.rpc.call("listpeers")
 	let nodes = []
 	for (const peer of peers) {
 		nodes.push(peer.id)
 		for (const channel of peer.channels) {
 			channel_peers[channel.short_channel_id] = peer
 		}
 	}
 }
 
 async function get_node(id) {
 	const {nodes} = await plugin.rpc.call("listnodes", {id})
 	return nodes && nodes[0]
 }
 
 function decode(bolt11) {
 	return plugin.rpc.call("decode", {string:bolt11})
 }
 
 async function plugin_init(params) {
 	const relay = params.options['nostr-relay']
 	const privkey = params.options['nostr-key']
 	const notify_pk = params.options['nostr-notify-key']
 	const pubkey = getPublicKey(privkey)
 	let eventList = params.options['nostr-events']
 	const pool = RelayPool([relay])
 
 	if (!eventList || eventList === 'all') {
 		eventList = EVENTS
 	} else {
 		eventList = eventList.split(',')
 	}
 
 	await gather_peer_info()
 
 	broadcast = async (params) => {
 		const evName = Object.keys(params)[0]
 		if (!eventList.includes(evName)) return
 
 		let res = null
 		try {
 			res = await handle_msg(notify_pk, evName, params)
 		} catch (e) {
 			await send_msg(pool, privkey, pubkey, {
 				content: `An error was thrown when handling the '${evName}' event: ${e.toString()}`
 			})
 			return
 		}
 		if (res === null)
 			return
 		if (typeof res === "string")
 			res = {content: res}
 		await send_msg(pool, privkey, pubkey, res)
 	  }
 }
 
 plugin.onInit = plugin_init
 
 async function format_sendpay_success(p)
 {
 	try {
 		const decoded = await decode(p.bolt11)
 		const desc = decoded && decoded.description
 		let dest = p.destination || (decoded && decoded.destination)
 		dest = (dest && await get_node_name(dest)) || dest || "?"
 		return `You sent ${p.amount_msat/1000} sats to ${dest}\n\n${desc}`
 	} catch {
 	}
 	return null
 }
 
 async function get_node_name(id)
 {
 	let mnode
 	try {
 		mnode = await get_node(id)
 	} catch {
 		return id
 	}
 	return mnode ? `'${mnode.alias}'` : id
 }
 
 function parse_msats(str)
 {
 	if (!str) {
 		return 0
 	}
 
 	if (typeof str !== 'string')
 		return str
 
 	return +(str.replace("msat",""))
 }
 
 function mksats(str)
 {
 	return `${parse_msats(str)/1000} sats`
 }
 
 function format_coin_movement(p)
 {
 	const credit = mksats(p.credit)
 	const debit = mksats(p.debit)
 	return `Coins have moved! ${p.type}\n\nCredit: ${credit}\nDebit: ${debit}`
 }
 
 function format_warning(p)
 {
 	if (p.source === "plugin-summary.py")
 		return null
 	return `Warning\n\n${p.log}`
 }
 
 async function peer_name(peer)
 {
 	if (!peer)
 		return null
 	return await get_node_name(peer.id)
 }
 
 function format_forward_status(stat)
 {
 	switch (stat)
 	{
 		case "local_failed": return "Failed to locally forward"
 		case "failed": return "Failed to forward"
 		case "settled": return "Forwarded"
 	}
 	return stat
 }
 
 function collect_status(stat)
 {
 	switch (stat)
 	{
 		case "local_failed":
 		case "failed": return "Failed to collect"
 		case "settled": return "Collected"
 	}
 	return "Collected"
 }
 
 async function format_channel_open(p)
 {
 	const name = await get_node_name(p.id)
 	const sats = mksats(p.amount)
 	return `Incoming channel from ${name} for ${sats}`
 }
 
 async function process_forward_event(p)
 {
 	if (p.status === "failed" || p.status === "local_failed")
 		return null
 
 	//forwarded[p.status] = forwarded[p.status] || {}
 	//let stats = forwarded[p.status]
 	const in_peer = channel_peers[p.in_channel]
 	const out_peer = channel_peers[p.out_channel]
 	const in_name = (await peer_name(in_peer)) || p.in_channel
 	const out_name = (await peer_name(out_peer)) || p.out_channel
 	const in_msats = parse_msats(p.in_msat)
 	const out_msats = parse_msats(p.out_msat)
 	const in_sats = in_msats / 1000.0
 	const out_sats = out_msats / 1000.0
 	const stat = format_forward_status(p.status)
 	const col = collect_status(p.status)
 	if (stat === "offered")
 		return null
 	const collected = (in_msats - out_msats)/1000.0
 	const reason = (p.reason && `Reason: ${p.reason}`) || ""
 	return `${stat}\n\nIn: ${in_name} ${in_sats}\nOut: ${out_name} ${out_sats}\n\n${col} ${collected}sats.\n${reason}`
 }
 
 function get_invoice_type(invoice)
 {
 	return (invoice.bolt11 && "bolt11") || (invoice.bolt12 && "bolt12") || "Unknown"
 }
 
 async function process_invoice_payment(notify_pk, params)
 {
 	const sats = mksats(params.msat)
 	const invoice = await get_invoice(params.label)
 	const content = `You got paid ${sats} for '${invoice.description}'`
 	const tags = [["p", notify_pk]]
 	return {content, tags}
 }
 
 async function get_invoice(label)
 {
 	const {invoices} = await plugin.rpc.call("listinvoices", {label})
 	return invoices && invoices[0]
 }
 
 async function process_invoice_creation(params)
 {
 	const invoice = await get_invoice(params.label)
 	return `Invoice created: '${invoice.description}'`
 }
 
 async function format_channel_state_changed(p)
 {
 	const node = await get_node_name(p.peer_id)
 	return `${node}'s channel (${p.short_channel_id}) changed from ${p.old_state} to ${p.new_state} caused by ${p.cause}.\n\n"${p.message}"`
 }
 
 async function handle_msg(notify_pk, name, params)
 {
 	if (name === "sendpay_success")
 		return await format_sendpay_success(params.sendpay_success)
 
 	if (name === "coin_movement")
 		return format_coin_movement(params.coin_movement)
 
 	if (name === "channel_opened")
 		return await format_channel_open(params.channel_opened)
 
 	if (name === "channel_state_changed")
 		return await format_channel_state_changed(params.channel_state_changed)
 
 	if (name === "warning")
 		return format_warning(params.warning)
 
 	if (name === "forward_event")
 		return await process_forward_event(params.forward_event)
 
 	if (name === "invoice_payment")
 		return process_invoice_payment(notify_pk, params.invoice_payment)
 
 	if (name === "invoice_creation")
 		return process_invoice_creation(params.invoice_creation)
 
 	return {content:name + ": \n\n" + JSON.stringify(params)}
 }
 
 const EVENTS = [
   'channel_opened',
   'channel_open_failed',
   'channel_state_changed',
   'invoice_payment',
   'invoice_creation',
   'warning',
   'forward_event',
   'sendpay_success',
   'shutdown'
 ]
 
 EVENTS.map((ev) => {
   plugin.subscribe(ev)
   plugin.notifications[ev].on(ev, (params) => {
     if (broadcast) {
       broadcast(params)
     }
   })
 })
 
 plugin.addOption('nostr-relay', 'ws://127.0.0.1:8080', 'nostr relay to send events to', 'string')
 plugin.addOption('nostr-key', 'hexstr of a 32byte key', 'nostr secret key', 'string')
 plugin.addOption('nostr-notify-key', 'pubkey to be notified for important events', 'nostr notify pubkey', 'string')
 plugin.addOption('nostr-events', 'all', 'List of events to broadcast. (Default: broadcast everything)', 'string')
 
 plugin.start()