cln-ledger

index.ts (6186B)

---

 
 import fs from 'fs';
 import readline from 'readline';
 import assert from 'assert';
 
 interface Zap {
 	kind: number;
 	content: string;
 	pubkey: string;
 	tags: string[][];
 }
 
 // Zap Types
 interface ZapProfileType {
 	type: "profile" // profile
 	pubkey: string
 }
 
 interface ZapEventType {
 	type: "event"
 	evid: string
 	pubkey: string
 }
 
 type ZapType = ZapProfileType | ZapEventType
 
 // Descriptions
 interface GenericDesc {
 	type: "generic" // generic
 	value: string
 }
 
 interface LNDesc {
 	type: "lnurl" // lnurl
 	description: string
 	address: string
 }
 
 interface ZapDesc {
 	type: "zap" // zap
 	zap_type: ZapType
 	zap: Zap
 }
 
 interface Routed {
 	type: "routed"
 }
 
 type Description = LNDesc | GenericDesc | ZapDesc | Routed
 
 interface Posting {
 	account: string;
 	amount: string;
 }
 
 interface Transaction {
 	date: Date;
 	description: Description;
 	postings: Posting[];
 }
 
 function description_string(desc: Description): string {
 	switch (desc.type) {
 	case "generic":
 		return desc.value
 	case "lnurl":
 		return desc.description
 	case "zap":
 		return "Zap"
 	}
 }
 
 function determine_zap_type(zap: Zap): ZapType {
 	const etag = get_tag(zap.tags, "e")
 	const ptag = get_tag(zap.tags, "p")
 
 	if (!ptag)
 		return null
 
 	if (!etag) {
 		let profile_zap: ZapProfileType = { pubkey: ptag, type: "profile" } 
 		return profile_zap
 	} 
 
 	let zap_ev: ZapEventType = { evid: etag, pubkey: ptag, type: "event" }
 	return zap_ev
 }
 
 function get_tag(tags: string[][], key: string): string {
 	let v = tags.find(tag => tag[0] === key)
 	return v && v[1]
 }
 
 function get_lnurl_description(json: string[][]): LNDesc {
 	const description = get_tag(json, "text/plain")
 	const address = get_tag(json, "text/identifier")
 	return { description, address, type: "lnurl" } 
 }
 
 function is_json(str: string): boolean {
 	return str[0] === '{' || (str[0] === '[' && str[1] === '[')
 }
 
 function create_generic_desc(value: string): GenericDesc {
 	return { type: "generic", value } 
 }
 
 function determine_description(str: string, tag: string): Description {
 	if (tag === "routed") {
 		let desc: Routed = { type: "routed" }
 		return desc
 	}
 
 	try {
 		let json
 		if (is_json(str) && (json = JSON.parse(str))) {
 			if (json.kind === 9734) {
 				let zaptype: ZapType = determine_zap_type(json)
 				let zap_desc: ZapDesc = { zap_type: zaptype, zap: json, type: "zap" }
 				return zap_desc
 			} else if (json.length > 0) {
 				return get_lnurl_description(json)
 			}
 
 			return create_generic_desc(str)
 		} 
 
 		return create_generic_desc(str)
 	} catch(e) {
 		return create_generic_desc(str)
 	}
 }
 
 function msat(val: number): string {
 	return `${val} msat`
 }
 
 function classify_account(str: string, debit: number):string {
 	if (str.includes("Damus Merch"))
 		return "merch:tshirt"
 	if (str.includes("Damus Hat"))
 		return "merch:hat"
 	if (str.includes("@tipjar"))
 		return "lnurl:jb55@sendsats.lol:tipjar"
 
 	if (debit === 1971000)
 		return "zap:1971"
 	else if (debit === 420000)
 		return "zap:420"
 
 	return "unknown"
 }
 
 function determine_postings(credit: number, debit: number, desc: Description): Posting[] {
 	let postings: Posting[] = []
 	const is_credit = credit > 0
 	const acct = is_credit? "income" : "expenses"
 	const amount = is_credit? credit : debit
 
 	switch (desc.type) {
 	case "routed":
 		postings.push({ account: `${acct}:routed`, amount: msat(is_credit? -amount : amount) })
 		postings.push({ account: `assets:cln`, amount: msat(is_credit? amount : -amount) })
 		break
 	case "generic":
 		// todo: categorize
 		const subacct = classify_account(desc.value, debit)
 		postings.push({ account: `${acct}:${subacct}`, amount: msat(is_credit? -amount : amount) })
 		postings.push({ account: `assets:cln`, amount: msat(is_credit? amount : -amount) })
 		break
 	case "lnurl":
 		assert(debit === 0)
 		postings.push({ account: `income:lnurl:${desc.address}`, amount: msat(-credit) })
 		postings.push({ account: `assets:cln`, amount: msat(credit) })
 		break
 	case "zap":
 		assert(debit === 0)
 		switch (desc.zap_type.type) {
 		case 'profile':
 			postings.push({ account: `income:zap:profile:${desc.zap_type.pubkey}`, amount: msat(-credit) })
 			break
 		case 'event':
 			// todo: attribute this to profile as well?
 			let evtype = desc.zap_type as ZapEventType
 			postings.push({ account: `income:zap:event:${evtype.evid}`, amount: msat(-credit) })
 			break
 		}
 		postings.push({ account: `assets:cln`, amount: msat(credit) })
 		break
 	}
 
 	return postings
 }
 
 async function process(filePath: string) {
   const fileStream = fs.createReadStream(filePath);
 
   const rl = readline.createInterface({
     input: fileStream,
     crlfDelay: Infinity
   });
   
 console.log("P 2022-07-22 msat 0.00000035 CAD")
 console.log("P 2022-07-22 msat 0.001 sat")
 console.log("P 2022-07-22 msat 0.00001 bit")
 console.log("P 2022-07-22 msat 0.00000000001 btc")
 
   for await (const line of rl) {
     let parts = line.split('\t');
     
     if(parts.length !== 6) {
       console.error(`Invalid line: ${line} ${parts.length} !== 5`);
       continue;
     }
 
     const credit = Number(parts[2])
     const debit = Number(parts[3])
 
     if (credit === 0 && debit === 0)
 	    continue
 
     const tag = parts[1]
 
     if (!(tag === "invoice" || tag === "routed"))
 	    continue
 
     const timestamp = Number(parts[4])
     const date = new Date(timestamp * 1000)
     const description = determine_description(parts[5], tag)
     const postings = determine_postings(credit, debit, description)
 
     // type,.tag,.credit_msat,.debit_msat,.timestamp,.description
     let transaction: Transaction = { date, description, postings };
     console.log(transactionToLedger(transaction));
   }
 }
 
 function format_date(date: Date): string {
   const year = date.getFullYear();
   const month = (date.getMonth() + 1).toString().padStart(2, '0');
   const day = date.getDate().toString().padStart(2, '0');
 
   return `${year}-${month}-${day}`;
 }
 
 function transactionToLedger(transaction: Transaction): string {
   const tx = `${format_date(transaction.date)}	${description_string(transaction.description)}\n`
   return tx + transaction.postings.map(p => `	${p.account}	${p.amount}`).join("\n") + "\n"
 }
 
 async function main() {
   await process('events.txt');
 }
 
 main().catch(console.error);