btc.ts

import { spawn } from 'child_process';
import * as bitcoin from 'bitcoinjs-lib';
import * as curve from 'tiny-secp256k1';
import { createInterface } from 'readline';
import { Writable } from 'stream';
import { ECPairFactory, ECPairInterface } from 'ecpair';
import { strict as assert } from 'assert';

export { descsumCreate } from './descriptors';

type ObjectKey = string | number | symbol;
type ObjectKeyString<K extends ObjectKey> = K extends number ? `${number}` : K extends Symbol ? never : K;

declare global {
	interface ObjectConstructor {
		entries<K extends ObjectKey, T>(o: { [s in K]: T } | ArrayLike<T>): [ObjectKeyString<K>, T][];
	}
}

const ECPair = ECPairFactory(curve);

export namespace Uint256 {
	export function toBigint(b: Uint8Array): bigint {
		return BigInt('0x' + Buffer.from(b).toString('hex'));
	}

	export function toBuffer(n: bigint): Buffer {
		return Buffer.from(n.toString(16).padStart(64, '0'), 'hex');
	}
}

export interface OutputPoint {
	txid: string;
	vout: number;
}

export interface UTXO extends OutputPoint {
	address: string;
	label?: string;
	scriptPubKey: string;
	amount: number;
	confirmations: number;
	ancestorcount?: number;
	ancestorsize?: number;
	ancestorfees?: number;
	redeemScript?: string;
	witnessScript?: string;
	spendable: boolean;
	solvable: boolean;
	reused?: boolean;
	desc?: string;
	parent_descs: string[];
	safe: boolean;
}

export interface RawTransactionInput extends OutputPoint {
	sequence?: number;
}

export type RawTransactionOutput =
	| {
			[address: string]: number;
	  }
	| {
			data: string;
	  };

export interface TemplateRequest {
	mode?: string;
	capabilities?: string[];
	rules: string[];
}

export interface BlockTemplateTX {
	data: string;
	txid: string;
	hash: string;
	depends: number[];
	TXdepends: BlockTemplateTX[];
	fee?: number;
	sigops?: number;
	weight: number;
}

export interface BlockTemplate {
	capabilities: string[];
	version: number;
	rules: string[];
	vbavailable: { [rulename: string]: number };
	vbrequired: number;
	previousblockhash: string;
	transactions: BlockTemplateTX[];
	coinbaseaux: { [key: string]: number };
	coinbasevalue: number;
	longpollid: string;
	target: string;
	mintime: number;
	mutable: string[];
	noncerange: string;
	sigoplimit: number;
	sizelimit: number;
	weightlimit: number;
	curtime: number;
	bits: string;
	height: number;
	signet_challenge?: string;
	default_witness_commitment?: string;
}

export type ScriptType =
	| 'nonstandard'
	| 'pubkey'
	| 'pubkeyhash'
	| 'scripthash'
	| 'multisig'
	| 'nulldata'
	| 'witness_v0_scripthash'
	| 'witness_v0_keyhash'
	| 'witness_v1_taproot'
	| 'witness_unknown';

export interface ScriptPubKey {
	asm: string;
	desc: string;
	hex: string;
	type: ScriptType;
	address?: string;
}

export interface Vin {
	coinbase?: string;
	txid?: string;
	vout?: number;
	scriptSig?: {
		asm: string;
		hex: string;
	};
	txinwitness?: string[];
	sequence: number;
}

export interface Vout {
	value: number;
	n: number;
	scriptPubKey: ScriptPubKey;
}

export interface RawTransaction {
	txid: string;
	hash: string;
	size: number;
	vsize: number;
	weight: number;
	version: number;
	locktime: number;
	vin: Vin[];
	vout: Vout[];
}

export interface TXOut {
	bestblock: string;
	confirmations: number;
	value: number;
	scriptPubKey: ScriptPubKey;
	coinbase: boolean;
}

export interface ListUnspentArgs {
	/** Default value: 1 */
	minconf?: number;
	/** Default value: 9999999 */
	maxconf?: number;
	/** Default value: [] */
	addresses?: string[];
	/** Default value: true */
	include_unsafe?: boolean;
	/** Default value: 0 */
	minimumAmount?: number;
	/** Default value: unlimited */
	maximumAmount?: number;
	/** Default value: unlimited */
	maximumCount?: number;
	/** Default value: unlimited */
	minimumSumAmount?: number;
}

export type TransactionType = string | Buffer | bitcoin.Transaction;
export type PsbtType = string | bitcoin.Psbt;

export type Chain = 'main' | 'test' | 'testnet4' | 'regtest' | 'signet';

export const networks: { [name in Chain]: bitcoin.networks.Network } = {
	main: bitcoin.networks.bitcoin,
	test: bitcoin.networks.testnet,
	testnet4: bitcoin.networks.testnet,
	regtest: bitcoin.networks.regtest,
	signet: bitcoin.networks.testnet
};

let chain: Chain = 'testnet4';
export let network = networks[chain];

export function setChain(c: Chain): void {
	chain = c;
	network = networks[chain];
}

export const chainEnvVarKey = 'BTC_STUFF_CHAIN';

const chainEnvVarValue = process.env[chainEnvVarKey];
if (chainEnvVarValue) {
	if (networks[chainEnvVarValue]) {
		setChain(chainEnvVarValue as Chain);
	} else {
		console.error(`Invalid chain "${chainEnvVarValue}", leaving it unchanged (currently set to ${chain})`);
	}
}

export async function btc(...args: (string | Buffer | number | {} | TransactionType | PsbtType)[]): Promise<string> {
	return new Promise((r, e) => {
		const cmdargs = [ `-chain=${chain}`, '-stdin' ];
		while (args.length && typeof args[0] === 'string' && args[0].startsWith('-')) {
			cmdargs.push(args.shift() as string);
		}

		const p = spawn('bitcoin-cli', cmdargs);

		let out = '';

		p.stdout.setEncoding('utf8');
		p.stdout.on('data', data => {
			out += data.toString();
		});

		p.stderr.setEncoding('utf8');
		p.stderr.on('data', data => {
			out += data.toString();
		});

		p.on('close', code => {
			while (out.endsWith('\n')) {
				out = out.slice(0, -1);
			}
			(code ? e : r)(out);
		});

		p.stdin.write(
			args
				.map(x => {
					let arg: string;
					if (Buffer.isBuffer(x)) {
						arg = x.toString('hex');
					} else if (typeof x === 'number') {
						arg = x.toString();
					} else if (typeof x === 'string') {
						arg = x;
					} else if (x instanceof bitcoin.Transaction) {
						arg = x.toHex();
					} else if (x instanceof bitcoin.Psbt) {
						arg = x.toBase64();
					} else {
						arg = JSON.stringify(x);
					}
					return arg.replace(/\n/g, '');
				})
				.join('\n')
		);
		p.stdin.end();
	});
}

// sign, create and send new transaction
export async function newtx(
	inputs: RawTransactionInput[],
	outputs: RawTransactionOutput | RawTransactionOutput[],
	sat: boolean
): Promise<string> {
	if (sat) {
		if (Array.isArray(outputs)) {
			for (const outs of outputs) {
				Object.keys(outs).forEach(k => {
					if (k !== 'data') {
						outs[k] = toBTC(outs[k]);
					}
				});
			}
		} else {
			Object.keys(outputs).forEach(k => {
				if (k !== 'data') {
					outputs[k] = toBTC(outputs[k]);
				}
			});
		}
	}
	const tx = await btc('createrawtransaction', inputs, outputs);
	return signAndSend(tx);
}

export async function signAndSend(tx: TransactionType): Promise<string> {
	return send(JSON.parse(await btc('signrawtransactionwithwallet', tx)).hex);
}

export async function fundTransaction(
	tx: TransactionType,
	convert: false
): Promise<{ hex: string; fee: number; changepos: number }>;
export async function fundTransaction(
	tx: TransactionType,
	convert?: true
): Promise<{ tx: bitcoin.Transaction; hex: string; fee: number; changepos: number }>;
export async function fundTransaction(
	tx: TransactionType,
	convert?: boolean
): Promise<{ tx?: bitcoin.Transaction; hex: string; fee: number; changepos: number }>;
export async function fundTransaction(
	tx: TransactionType,
	convert = true
): Promise<{ tx: bitcoin.Transaction; hex: string; fee: number; changepos: number }> {
	const res = JSON.parse(await btc('fundrawtransaction', tx));

	if (convert) {
		res.tx = bitcoin.Transaction.fromHex(res.hex);
	}

	return res;
}

export async function send(tx: TransactionType): Promise<string> {
	return btc('sendrawtransaction', tx);
}

/** @deprecated Use listUnspent instead */
export async function listunspent(minamount: number, minconf: number, sat: boolean): Promise<UTXO[]> {
	return JSON.parse(
		await btc('-named', 'listunspent', 'minconf=' + minconf, `query_options={"minimumAmount":${minamount}}`)
	).map((u: UTXO) => {
		if (sat) {
			u.amount = toSat(u.amount);
		}
		return u;
	});
}

/** Lists unspent transaction outputs (UTXOs) */
export async function listUnspent(args: ListUnspentArgs = {}, sats = true): Promise<UTXO[]> {
	const minconf = args.minconf === undefined ? 1 : args.minconf;
	const maxconf = args.maxconf === undefined ? 9999999 : args.maxconf;
	const addresses = args.addresses || [];
	const include_unsafe = args.include_unsafe === undefined ? true : args.include_unsafe;
	const query_options = {};
	for (const k in args) {
		if ([ 'minimumAmount', 'maximumAmount', 'maximumCount', 'minimumSumAmount' ].includes(k)) {
			query_options[k] = sats && k.endsWith('Amount') ? toBTC(args[k]) : args[k];
		}
	}
	const utxos: UTXO[] = JSON.parse(
		await btc('listunspent', minconf, maxconf, addresses, include_unsafe, query_options)
	);
	if (sats) {
		for (let i = 0; i < utxos.length; i++) {
			utxos[i].amount = toSat(utxos[i].amount);
		}
	}
	return utxos;
}

export async function getnewaddress(): Promise<string> {
	return btc('getnewaddress');
}

export async function getBlockTemplate(
	template_request: TemplateRequest = { rules: [ 'segwit' ] }
): Promise<BlockTemplate> {
	const template: BlockTemplate = JSON.parse(await btc('getblocktemplate', template_request));
	updateTXDepends(template);
	return template;
}

export async function decodeRawTransaction(tx: TransactionType): Promise<RawTransaction> {
	return JSON.parse(await btc('decoderawtransaction', tx));
}

export async function getTXOut(txid: string | Buffer, vout: number, include_mempool = true): Promise<TXOut | void> {
	const txout = await btc('gettxout', txidToString(txid), vout, include_mempool);
	if (txout) {
		return JSON.parse(txout);
	}
}

export namespace getTransaction {
	interface DetailsBase {
		involvesWatchonly?: boolean;
		address?: string;
		amount: number;
		label?: string;
		vout: number;
	}

	export interface OutputNoDecodedTx {
		amount: number;
		fee?: number;
		confirmations: number;
		generated?: boolean;
		trusted?: boolean;
		blockhash?: string;
		blockheight?: number;
		blockindex?: number;
		blocktime?: number;
		txid: string;
		wtxid: string;
		walletconflicts: string[];
		replaced_by_txid?: string;
		replaces_txid?: string;
		// comment?: string;
		to?: string;
		time: number;
		timereceived: number;
		comment?: string;
		'bip125-replaceable': 'yes' | 'no' | 'unknown';
		details: (
			| (DetailsBase & { category: 'receive'; parent_descs: string[] })
			| (DetailsBase & { category: 'generate' | 'immature' | 'orphan' })
			| (DetailsBase & { category: 'send'; fee: number; abandoned: boolean })
		)[];
		hex: string;
	}

	export interface OutputDecodedTx extends OutputNoDecodedTx {
		decoded: RawTransaction;
	}

	export interface Output extends OutputNoDecodedTx {
		decoded?: RawTransaction;
	}
}

export async function getTransaction(
	txid: string | Buffer,
	includeWatchonly: boolean,
	verbose?: false
): Promise<getTransaction.OutputNoDecodedTx>;
export async function getTransaction(
	txid: string | Buffer,
	includeWatchonly: boolean,
	verbose: true
): Promise<getTransaction.OutputDecodedTx>;
export async function getTransaction(
	txid: string | Buffer,
	includeWatchonly?: boolean,
	verbose?: boolean
): Promise<getTransaction.Output>;
export async function getTransaction(
	txid: string | Buffer,
	includeWatchonly = true,
	verbose = false
): Promise<getTransaction.Output> {
	return JSON.parse(await btc('gettransaction', txidToString(txid), includeWatchonly, verbose));
}

export namespace testMempoolAccept {
	interface Transaction {
		txid: string;
		wtxid: string;
		allowed: boolean;
	}

	export interface AllowedTransaction extends Transaction {
		allowed: true;
		vsize: number;
		fees: { base: number };
	}

	export interface RejectedTransaction extends Transaction {
		allowed: false;
		'reject-reason': string;
	}

	export interface RejectedPackageTransaction extends RejectedTransaction {
		'package-error'?: string;
	}

	export type SingleOutput = AllowedTransaction | RejectedTransaction;
	export type PackageOutput = (AllowedTransaction | RejectedPackageTransaction)[];
	export type Output = SingleOutput | PackageOutput;
}

/** note: maxfeerate is in sat/vB */
export async function testMempoolAccept(tx: TransactionType, maxfee?: number): Promise<testMempoolAccept.SingleOutput>;
export async function testMempoolAccept(
	txs: TransactionType[],
	maxfee?: number
): Promise<testMempoolAccept.PackageOutput>;
export async function testMempoolAccept(
	txs: TransactionType | TransactionType[],
	maxfeerate?: number
): Promise<testMempoolAccept.Output>;
export async function testMempoolAccept(
	txs: TransactionType | TransactionType[],
	maxfeerate?: number
): Promise<testMempoolAccept.Output> {
	const arr = Array.isArray(txs);
	const res = JSON.parse(
		await (maxfeerate === undefined
			? btc('testmempoolaccept', arr ? txs : [ txs ])
			: btc('testmempoolaccept', arr ? txs : [ txs ], toBTCkvB(maxfeerate)))
	);
	return arr ? res : res[0];
}

export namespace getChainTips {
	interface ChainTip {
		height: number;
		hash: string;
	}

	export interface ActiveChainTip extends ChainTip {
		branchlen: 0;
		status: 'active';
	}

	export interface InactiveChainTip extends ChainTip {
		branchlen: number;
		status: 'invalid' | 'headers-only' | 'valid-headers' | 'valid-fork' | 'unknown';
	}

	// export type Output = [ ActiveChainTip, ...InactiveChainTip[] ];
	export type Output = (ActiveChainTip | InactiveChainTip)[];
}

export async function getChainTips(): Promise<getChainTips.Output> {
	return JSON.parse(await btc('getchaintips'));
}

export namespace getIndexInfo {
	type BlockFilterIndex = 'basic';

	export type Index = `${'tx' | 'coinstats' | `${BlockFilterIndex} block filter `}index`;

	export interface IndexInfo {
		synced: boolean;
		best_block_height: number;
	}

	export type Output<T extends Index = Index> = {
		[k in T]?: IndexInfo;
	};
}

export async function getIndexInfo(): Promise<getIndexInfo.Output>;
export async function getIndexInfo(index: getIndexInfo.Index): Promise<getIndexInfo.Output<typeof index>>;
export async function getIndexInfo(index?: getIndexInfo.Index): Promise<getIndexInfo.Output>;
export async function getIndexInfo(index?: getIndexInfo.Index): Promise<getIndexInfo.Output> {
	return JSON.parse(await btc('getindexinfo', index || ''));
}

export namespace getBlockChainInfo {
	interface ChainInfoBase {
		chain: Chain;
		blocks: number;
		headers: number;
		bestblockhash: string;
		difficulty: number;
		time: number;
		mediantime: number;
		verificationprogress: number;
		initialblockdownload: boolean;
		chainwork: string;
		size_on_disk: number;
		pruned: boolean;
		warnings: string;
	}

	interface ChainInfo extends ChainInfoBase {
		pruned: false;
	}

	interface PruneChainInfoBase extends ChainInfoBase {
		pruned: true;
		pruneheight: number;
		automatic_pruning: boolean;
	}

	interface PruneChainInfo extends PruneChainInfoBase {
		automatic_pruning: false;
	}

	interface AutomaticPruneChainInfo extends PruneChainInfoBase {
		automatic_pruning: true;
		prune_target_size: number;
	}

	export type Output = ChainInfo | PruneChainInfo | AutomaticPruneChainInfo;
}

export async function getBlockChainInfo(): Promise<getBlockChainInfo.Output> {
	return JSON.parse(await btc('getblockchaininfo'));
}

export async function fundOutputScript(
	scriptPubKey: Buffer,
	amount: number,
	locktime = 0,
	version = 2
): Promise<{ txid: string; txidBytes: Buffer; vout: number; hex: string }> {
	const tx = new bitcoin.Transaction();

	tx.version = version;
	tx.addOutput(scriptPubKey, amount);
	tx.locktime = locktime;

	const funded = await fundTransaction(tx, true);
	const vout = funded.tx.outs.findIndex(output => output.value === amount && output.script.equals(scriptPubKey));
	assert(vout != -1);
	await signAndSend(funded.hex);
	return {
		txid: funded.tx.getId(),
		txidBytes: Buffer.from(funded.tx.getId(), 'hex').reverse(),
		vout,
		hex: funded.hex
	};
}

/** @deprecated Use `fundOutputScript(bitcoin.address.toOutputScript(address, network), amount)` instead */
export async function fundAddress(address: string, amount: number): Promise<OutputPoint> {
	const txid = await btc('sendtoaddress', address, toBTC(amount));
	const vout = (await getTransaction(txid)).details.find(x => x.address == address).vout;

	return { txid, vout };
}

export function validNetworks(address: string): { [name in 'bitcoin' | 'testnet' | 'regtest']?: bitcoin.Network } {
	const output: { [name in 'bitcoin' | 'testnet' | 'regtest']?: bitcoin.Network } = {};

	for (const net of Object.entries(bitcoin.networks)) {
		try {
			bitcoin.address.toOutputScript(address, net[1]);
			output[net[0]] = net[1];
		} catch (e) {}
	}

	return output;
}

export const OP_CHECKSIGADD = 0xba; // this is not merged yet: https://github.com/bitcoinjs/bitcoinjs-lib/pull/1742

const ONE = Uint256.toBuffer(1n);
const N_LESS_1 = Buffer.from(curve.privateSub(ONE, Uint256.toBuffer(2n))!);

export function negateIfOddPubkey(d: Uint8Array): Buffer | undefined {
	const pub = curve.pointFromScalar(d, true);
	if (!pub) {
		return;
	}
	if (pub[0] == 3) {
		const d1 = curve.privateSub(N_LESS_1, d);
		if (!d1) {
			return;
		}
		const d2 = curve.privateAdd(d1, ONE);
		if (!d2) {
			return;
		}
		return Buffer.from(d2);
	}
	return Buffer.from(d);
}

// const EC_P = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn // not used yet
const EC_N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;

export function ecPrivateMul(a: Uint8Array, b: Uint8Array): Buffer {
	const an = Uint256.toBigint(a);
	const bn = Uint256.toBigint(b);
	if (an <= 0n || an >= EC_N) {
		throw new Error('a out of range');
	}
	if (bn <= 0n || bn >= EC_N) {
		throw new Error('b out of range');
	}
	return Uint256.toBuffer((an * bn) % EC_N);
}

export function ecPrivateInv(a: Uint8Array): Buffer {
	let an = Uint256.toBigint(a);
	if (an <= 0n || an >= EC_N) {
		throw new Error('a out of range');
	}

	let m = EC_N;
	let y1 = 1n;
	let y2 = 0n;
	while (an > 1) {
		[ y1, y2 ] = [ y2 - (m / an) * y1, y1 ];
		[ an, m ] = [ m % an, an ];
	}
	return Uint256.toBuffer(((y1 % EC_N) + EC_N) % EC_N);
}

export function ecPrivateDiv(a: Uint8Array, b: Uint8Array): Buffer {
	return ecPrivateMul(a, ecPrivateInv(b));
}

export function tapLeaf(script: Buffer): Buffer {
	return bitcoin.crypto.taggedHash(
		'TapLeaf',
		Buffer.concat([ Buffer.from([ 0xc0 ]), encodeVarUintLE(script.length), script ])
	);
}

export function tapBranch(branch1: Buffer, branch2: Buffer): Buffer {
	return bitcoin.crypto.taggedHash(
		'TapBranch',
		Buffer.concat(branch1 < branch2 ? [ branch1, branch2 ] : [ branch2, branch1 ])
	);
}

export function tapTweak(pubkey: Buffer, root?: Buffer): Buffer {
	return bitcoin.crypto.taggedHash('TapTweak', root ? Buffer.concat([ pubkey.slice(-32), root ]) : pubkey.slice(-32));
}

export function bip86(ecpair: ECPairInterface): ECPairInterface | undefined {
	const tweak = tapTweak(ecpair.publicKey);
	const opts = {
		compressed: ecpair.compressed,
		network: ecpair.network
	};
	if (ecpair.privateKey) {
		const priv = curve.privateAdd(ecpair.privateKey, tweak);
		if (!priv) {
			return;
		}
		return ECPair.fromPrivateKey(Buffer.from(priv), opts);
	}
	const pub = curve.pointAddScalar(ecpair.publicKey, tweak);
	if (!pub) {
		return;
	}
	return ECPair.fromPublicKey(Buffer.from(pub), opts);
}

export function createTaprootOutput(
	pubkey: Buffer,
	root?: Buffer
): { key: Buffer; parity: 0 | 1; scriptPubKey: Buffer; address: string } | undefined {
	const tweaked = curve.pointAddScalar(pubkey, tapTweak(pubkey, root));
	if (!tweaked) {
		return;
	}
	const key = Buffer.from(tweaked).slice(-32);
	return {
		key,
		parity: (tweaked[0] & 1) as 0 | 1,
		scriptPubKey: bitcoin.script.compile([ bitcoin.opcodes.OP_1, key ]),
		address: bitcoin.address.toBech32(key, 1, network.bech32)
	};
}

// Utils

export function encodeVarUintLE(n: bigint | number): Buffer {
	if (typeof n === 'number') {
		assert(n >= 0 && n <= Number.MAX_SAFE_INTEGER && n % 1 === 0);
		n = BigInt(n);
	} else {
		assert(n >= 0n && n <= 0xffffffffffffffffn);
	}
	if (n > 0xffffffffn) {
		const buf = Buffer.allocUnsafe(9);
		buf.writeUint8(0xff);
		buf.writeBigUint64LE(n, 1);
		return buf;
	} else if (n > 0xffffn) {
		const buf = Buffer.allocUnsafe(5);
		buf.writeUint8(0xfe);
		buf.writeUint32LE(Number(n), 1);
		return buf;
	} else if (n > 0xfcn) {
		const buf = Buffer.allocUnsafe(3);
		buf.writeUint8(0xfd);
		buf.writeUint16LE(Number(n), 1);
		return buf;
	} else {
		const buf = Buffer.allocUnsafe(1);
		buf.writeUint8(Number(n));
		return buf;
	}
}

export function decodeVarUintLE(buf: Buffer, bigint: true): bigint;
export function decodeVarUintLE(buf: Buffer, bigint: false): number;
export function decodeVarUintLE(buf: Buffer, bigint: boolean): bigint | number;
export function decodeVarUintLE(buf: Buffer, bigint: boolean): bigint | number {
	let n: number;
	if (buf[0] === 0xff && buf.length >= 9) {
		const n = buf.readBigUint64LE(1);
		if (bigint) {
			return n;
		} else {
			assert(n <= Number.MAX_SAFE_INTEGER);
			return Number(n);
		}
	} else if (buf[0] === 0xfe && buf.length >= 5) {
		n = buf.readUint32LE(1);
	} else if (buf[0] === 0xfd && buf.length >= 3) {
		n = buf.readUint16LE(1);
	} else {
		n = buf.readUint8();
	}
	return bigint ? BigInt(n) : n;
}

// remove a transaction from a templateFile
// removes all dependendencies
// subtracts fee of removed transactions from coinbasevalue
// returns all removed transactions
export function removeTransaction(template: BlockTemplate, txid: string): BlockTemplateTX[] {
	const txs = template.transactions;
	const tx = txs.find(x => x.txid == txid);
	if (!tx) {
		return [];
	}
	const toRemove = [ tx ];
	const removed: BlockTemplateTX[] = [];

	while (toRemove.length) {
		const tx = toRemove.shift()!;
		toRemove.push(...tx.TXdepends);
		removed.push(...txs.splice(txs.indexOf(tx), 1));
	}

	template.coinbasevalue -= removed.reduce((v, x) => v + (x.fee || 0), 0);

	updateNumberDepends(template);

	return removed;
}

export async function insertTransaction(template: BlockTemplate, data: string | Buffer): Promise<boolean> {
	const rawtx = await decodeRawTransaction(data);

	if (template.transactions.find(x => x.txid == rawtx.txid)) {
		return false;
	}

	const tx: BlockTemplateTX = {
		data: Buffer.isBuffer(data) ? data.toString('hex') : data,
		txid: rawtx.txid,
		hash: rawtx.hash,
		depends: [],
		TXdepends: template.transactions.filter(x => rawtx.vin.map(y => y.txid).includes(x.txid)),
		weight: rawtx.weight
	};

	template.transactions.push(tx);

	updateNumberDepends(template);

	return true;
}

function updateTXDepends(template: BlockTemplate): void {
	for (const tx of template.transactions) {
		tx.TXdepends = tx.depends.map(i => template.transactions[i - 1]);
	}
}

function updateNumberDepends(template: BlockTemplate): void {
	for (const tx of template.transactions) {
		tx.depends = tx.TXdepends.map(tx => template.transactions.indexOf(tx) + 1);
	}
}

export function bech32toScriptPubKey(a: string): Buffer {
	const z = bitcoin.address.fromBech32(a);
	return bitcoin.script.compile([ bitcoin.script.number.encode(z.version), bitcoin.address.fromBech32(a).data ]);
}

export function p2pkh(pub: Buffer): Buffer {
	return bitcoin.script.compile([
		bitcoin.opcodes.OP_DUP,
		bitcoin.opcodes.OP_HASH160,
		bitcoin.crypto.hash160(pub),
		bitcoin.opcodes.OP_EQUALVERIFY,
		bitcoin.opcodes.OP_CHECKSIG
	]);
}

/** @deprecated Use `Buffer.from` instead */
export function cloneBuf(buf: Buffer): Buffer {
	return Buffer.from(buf);
}

export function txidToString(txid: string | Buffer): string {
	if (typeof txid === 'string') {
		return txid;
	}
	return Buffer.from(txid).reverse().toString('hex');
}

export function toSat(btcAmount: number): number {
	// prevent floating point quirks: 4.24524546 * 1e8 = 424524545.99999994
	return Math.round(btcAmount * 1e8);
}

export function toBTC(satAmount: number): number {
	// prevent floating point quirks: 424524546 * 1e-8 = 4.2452454600000005
	return parseFloat((satAmount * 1e-8).toFixed(8));
}

/** Converts a fee rate in BTC/kvB to sat/vB */
export function toSatvB(btckvB: number): number {
	return toSat(btckvB) / 1000;
}

/** Converts a fee rate in sat/vB to BTC/kvB */
export function toBTCkvB(satvB: number): number {
	return toBTC(Math.round(satvB * 1000));
}

const eofCallbacks: (() => void)[] = [];
export function inputOnEOF(cb: () => void): void {
	eofCallbacks.push(cb);
}

export async function input(q: string, hide = false): Promise<string> {
	let active = false;

	const rl = createInterface({
		input: process.stdin,
		output: new Writable({
			write: (chunk, encoding, cb) => {
				const c = Buffer.from(chunk, encoding);

				if (active && hide) {
					if (c.toString() == '\r\n' || c.toString() == '\n') {
						console.log();
						return cb();
					}
				} else {
					process.stdout.write(c);
				}

				cb();
			}
		}),
		terminal: true
	});

	return new Promise(r => {
		let resolved = false;
		rl.question(q, a => {
			r(a);
			resolved = true;
			rl.close();
		});
		rl.on('close', () => {
			if (!resolved) {
				console.log();
				eofCallbacks.forEach(cb => cb());
			}
		});

		active = true;
	});
}

export async function sleep(ms: number): Promise<void> {
	return new Promise(r => setTimeout(r, ms));
}

// from https://stackoverflow.com/a/47296370/13800918, edited
export const consoleTrace = Object.fromEntries(
	([ 'log', 'warn', 'error' ] as const).map(methodName => {
		return [
			methodName,
			// eslint-disable-next-line @typescript-eslint/no-explicit-any
			(...args: any[]) => {
				let initiator = 'unknown place';
				try {
					throw new Error();
				} catch (e) {
					if (e instanceof Error && e.stack) {
						let isFirst = true;
						for (const line of e.stack.split('\n')) {
							const matches = line.match(/^\s+at\s+(.*)/);
							if (matches) {
								if (!isFirst) {
									initiator = matches[1];
									break;
								}
								isFirst = false;
							}
						}
					}
				}
				console[methodName](...args, '\n', `	at ${initiator}`);
			}
		];
	})
);