ecash-lib 1.2.2-rc9 → 1.4.0

package/src/script.ts

@@ -0,0 +1,195 @@
+// Copyright (c) 2024 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+import { readVarSize, writeVarSize } from './io/varsize.js';
+import { Writer } from './io/writer.js';
+import { WriterLength } from './io/writerlength.js';
+import { WriterBytes } from './io/writerbytes.js';
+import { toHex, fromHex } from './io/hex.js';
+import { Op, pushBytesOp, readOp, writeOp } from './op.js';
+import {
+    OP_CHECKSIG,
+    OP_CODESEPARATOR,
+    OP_DUP,
+    OP_EQUAL,
+    OP_EQUALVERIFY,
+    OP_HASH160,
+} from './opcode.js';
+import { Bytes } from './io/bytes.js';
+import { Address } from './address/address';
+
+/** A Bitcoin Script locking/unlocking a UTXO */
+export class Script {
+    public bytecode: Uint8Array;
+
+    /** Create a new Script with the given bytecode or empty */
+    public constructor(bytecode?: Uint8Array) {
+        this.bytecode = bytecode ?? new Uint8Array();
+    }
+
+    /**
+     * Write the script to the writer with the script size as VARINT
+     * prepended.
+     **/
+    public writeWithSize(writer: Writer) {
+        writeVarSize(this.bytecode.length, writer);
+        writer.putBytes(this.bytecode);
+    }
+
+    public static readWithSize(bytes: Bytes) {
+        const size = readVarSize(bytes);
+        return new Script(bytes.readBytes(Number(size)));
+    }
+
+    /** Build a Script from the given Script Ops */
+    public static fromOps(ops: Op[]): Script {
+        let scriptSize = 0;
+        for (const op of ops) {
+            const writerLength = new WriterLength();
+            writeOp(op, writerLength);
+            scriptSize += writerLength.length;
+        }
+        const bytecodeWriter = new WriterBytes(scriptSize);
+        for (const op of ops) {
+            writeOp(op, bytecodeWriter);
+        }
+        return new Script(bytecodeWriter.data);
+    }
+
+    public static fromAddress(address: string): Script {
+        // make Address from address
+        const thisAddress = Address.fromCashAddress(address);
+
+        switch (thisAddress.type) {
+            case 'p2pkh': {
+                return Script.p2pkh(fromHex(thisAddress.hash));
+            }
+            case 'p2sh': {
+                return Script.p2sh(fromHex(thisAddress.hash));
+            }
+            default: {
+                // Note we should never get here, as Address constructor
+                // only supports p2pkh and p2sh
+                throw new Error(
+                    `Unsupported address type: ${thisAddress.type}`,
+                );
+            }
+        }
+    }
+
+    /** Iterate over the Ops of this Script */
+    public ops(): ScriptOpIter {
+        return new ScriptOpIter(new Bytes(this.bytecode));
+    }
+
+    /** Create a deep copy of this Script */
+    public copy(): Script {
+        return new Script(new Uint8Array(this.bytecode));
+    }
+
+    /**
+     * Find the n-th OP_CODESEPARATOR (0-based) and cut out the bytecode
+     * following it. Required for signing BIP143 scripts that have an
+     * OP_CODESEPARATOR.
+     *
+     * Throw an error if the n-th OP_CODESEPARATOR doesn't exist.
+     *
+     * Historically this opcode has been seen as obscure and useless, but in
+     * BIP143 sighash-based covenants, basically every covenant benefits from
+     * its usage, by trimming down the sighash preimage size and thus tx size.
+     *
+     * Really long Scripts will have a big BIP143 preimage, which costs precious
+     * bytes (and the preimage might even go over the 520 pushdata limit).
+     * This can be trimmed down to just one single byte by ending the covenant
+     * in `... OP_CODESEPARATOR OP_CHECKSIG`, in which case the BIP143 signature
+     * algo will cut out everything after the OP_CODESEPARATOR, so only the
+     * OP_CHECKSIG remains.
+     * If the covenant bytecode is 520 or so, this would save 519 bytes.
+     */
+    public cutOutCodesep(nCodesep: number): Script {
+        const ops = this.ops();
+        let op: Op | undefined;
+        let nCodesepsFound = 0;
+        while ((op = ops.next()) !== undefined) {
+            if (op == OP_CODESEPARATOR) {
+                if (nCodesepsFound == nCodesep) {
+                    return new Script(this.bytecode.slice(ops.bytes.idx));
+                }
+                nCodesepsFound++;
+            }
+        }
+        throw new Error('OP_CODESEPARATOR not found');
+    }
+
+    /**
+     * Whether the Script is a P2SH Script.
+     * Matches CScript::IsPayToScriptHash in /src/script/script.h.
+     **/
+    public isP2sh(): boolean {
+        if (this.bytecode.length != 23) {
+            return false;
+        }
+        return (
+            this.bytecode[0] == OP_HASH160 &&
+            this.bytecode[1] == 20 &&
+            this.bytecode[22] == OP_EQUAL
+        );
+    }
+
+    /**
+     * Return hex string of this Script's bytecode
+     */
+    public toHex(): string {
+        return toHex(this.bytecode);
+    }
+
+    /** Build a P2SH script for the given script hash */
+    public static p2sh(scriptHash: Uint8Array): Script {
+        if (scriptHash.length !== 20) {
+            throw new Error(
+                `scriptHash length must be 20, got ${scriptHash.length}`,
+            );
+        }
+        return Script.fromOps([OP_HASH160, pushBytesOp(scriptHash), OP_EQUAL]);
+    }
+
+    /** Build a P2PKH script for the given public key hash */
+    public static p2pkh(pkh: Uint8Array): Script {
+        if (pkh.length !== 20) {
+            throw new Error(`pkh length must be 20, got ${pkh.length}`);
+        }
+        return Script.fromOps([
+            OP_DUP,
+            OP_HASH160,
+            pushBytesOp(pkh),
+            OP_EQUALVERIFY,
+            OP_CHECKSIG,
+        ]);
+    }
+
+    /** Build a scriptSig for spending a P2PKH output */
+    public static p2pkhSpend(pk: Uint8Array, sig: Uint8Array): Script {
+        return Script.fromOps([pushBytesOp(sig), pushBytesOp(pk)]);
+    }
+}
+
+/** Iterator over the Ops of a Script. */
+export class ScriptOpIter {
+    bytes: Bytes;
+
+    public constructor(bytes: Bytes) {
+        this.bytes = bytes;
+    }
+
+    /**
+     * Read the next Op and return it, or `undefined` if there are no more Ops.
+     * Throws an error if reading the next op failed.
+     */
+    public next(): Op | undefined {
+        if (this.bytes.idx >= this.bytes.data.length) {
+            return undefined;
+        }
+        return readOp(this.bytes);
+    }
+}

package/src/sigHashType.ts

@@ -0,0 +1,190 @@
+// Copyright (c) 2024 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+/** Type of sighash used to sign for an input for a OP_CHECKSIG operation. */
+export class SigHashType {
+    /** Variant of the sighash, e.g. LEGACY or BIP143 */
+    public variant: SigHashTypeVariant;
+    /** How inputs are signed, e.g. FIXED or ANYONECANPAY */
+    public inputType: SigHashTypeInputs;
+    /** How outputs are signed, e.g. ALL, NONE or SINGLE */
+    public outputType: SigHashTypeOutputs;
+
+    public constructor(params: {
+        variant: SigHashTypeVariant;
+        inputType: SigHashTypeInputs;
+        outputType: SigHashTypeOutputs;
+    }) {
+        this.variant = params.variant;
+        this.inputType = params.inputType;
+        this.outputType = params.outputType;
+    }
+
+    /** Reconstruct a SigHashType from the flags */
+    public static fromInt(flags: number): SigHashType | undefined {
+        if (flags > 0xff || flags < 0) {
+            return undefined;
+        }
+        // No bits may be set other than 0x80, 0x40, 0x02 and 0x01
+        if ((flags & 0x3c) != 0) {
+            return undefined;
+        }
+        const outputFlags = flags & 0x03;
+        if (outputFlags == 0) {
+            // 0 is not a valid output type
+            return undefined;
+        }
+        return new SigHashType({
+            variant:
+                flags & 0x40
+                    ? SigHashTypeVariant.BIP143
+                    : SigHashTypeVariant.LEGACY,
+            inputType:
+                flags & 0x80
+                    ? SigHashTypeInputs.ANYONECANPAY
+                    : SigHashTypeInputs.FIXED,
+            outputType:
+                outputFlags == 1
+                    ? SigHashTypeOutputs.ALL
+                    : outputFlags == 2
+                      ? SigHashTypeOutputs.NONE
+                      : SigHashTypeOutputs.SINGLE,
+        });
+    }
+
+    /** Get the sighash type as integer flags */
+    public toInt(): number {
+        return this.variant | this.inputType | this.outputType;
+    }
+}
+
+/** Variant of the sighash */
+export enum SigHashTypeVariant {
+    /** Original Satoshi, pre-BIP143 sighash */
+    LEGACY = 0,
+    /** New BIP143 sighash introduced by UAHF */
+    BIP143 = 0x40,
+}
+
+/** How tx inputs are signed */
+export enum SigHashTypeInputs {
+    /** Inputs are fixed, no other inputs can added/removeed */
+    FIXED = 0,
+    /** Inputs are arbitrary, other inputs can be added/removed */
+    ANYONECANPAY = 0x80,
+}
+
+/** How tx outputs are signed */
+export enum SigHashTypeOutputs {
+    /** All outputs are signed, no outputs can be added/removed */
+    ALL = 1,
+    /** No outputs are signed, they can be anything */
+    NONE = 2,
+    /** The output with the identical index as this input is signed */
+    SINGLE = 3,
+}
+
+/** ALL|BIP143 */
+export const ALL_BIP143: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.BIP143,
+    inputType: SigHashTypeInputs.FIXED,
+    outputType: SigHashTypeOutputs.ALL,
+});
+
+/** ALL|ANYONECANPAY|BIP143 */
+export const ALL_ANYONECANPAY_BIP143: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.BIP143,
+    inputType: SigHashTypeInputs.ANYONECANPAY,
+    outputType: SigHashTypeOutputs.ALL,
+});
+
+/** NONE|BIP143 */
+export const NONE_BIP143: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.BIP143,
+    inputType: SigHashTypeInputs.FIXED,
+    outputType: SigHashTypeOutputs.NONE,
+});
+
+/** NONE|ANYONECANPAY|BIP143 */
+export const NONE_ANYONECANPAY_BIP143: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.BIP143,
+    inputType: SigHashTypeInputs.ANYONECANPAY,
+    outputType: SigHashTypeOutputs.NONE,
+});
+
+/** SINGLE|BIP143 */
+export const SINGLE_BIP143: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.BIP143,
+    inputType: SigHashTypeInputs.FIXED,
+    outputType: SigHashTypeOutputs.SINGLE,
+});
+
+/** SINGLE|ANYONECANPAY|BIP143 */
+export const SINGLE_ANYONECANPAY_BIP143: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.BIP143,
+    inputType: SigHashTypeInputs.ANYONECANPAY,
+    outputType: SigHashTypeOutputs.SINGLE,
+});
+
+/** ALL|LEGACY */
+export const ALL_LEGACY: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.LEGACY,
+    inputType: SigHashTypeInputs.FIXED,
+    outputType: SigHashTypeOutputs.ALL,
+});
+
+/** ALL|ANYONECANPAY|LEGACY */
+export const ALL_ANYONECANPAY_LEGACY: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.LEGACY,
+    inputType: SigHashTypeInputs.ANYONECANPAY,
+    outputType: SigHashTypeOutputs.ALL,
+});
+
+/** NONE|LEGACY */
+export const NONE_LEGACY: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.LEGACY,
+    inputType: SigHashTypeInputs.FIXED,
+    outputType: SigHashTypeOutputs.NONE,
+});
+
+/** NONE|ANYONECANPAY|LEGACY */
+export const NONE_ANYONECANPAY_LEGACY: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.LEGACY,
+    inputType: SigHashTypeInputs.ANYONECANPAY,
+    outputType: SigHashTypeOutputs.NONE,
+});
+
+/** SINGLE|LEGACY */
+export const SINGLE_LEGACY: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.LEGACY,
+    inputType: SigHashTypeInputs.FIXED,
+    outputType: SigHashTypeOutputs.SINGLE,
+});
+
+/** SINGLE|ANYONECANPAY|LEGACY */
+export const SINGLE_ANYONECANPAY_LEGACY: SigHashType = new SigHashType({
+    variant: SigHashTypeVariant.LEGACY,
+    inputType: SigHashTypeInputs.ANYONECANPAY,
+    outputType: SigHashTypeOutputs.SINGLE,
+});
+
+/** List of BIP143 sighashes (FORKID) */
+export const SIG_HASH_TYPES_BIP143 = [
+    ALL_BIP143,
+    ALL_ANYONECANPAY_BIP143,
+    NONE_BIP143,
+    NONE_ANYONECANPAY_BIP143,
+    SINGLE_BIP143,
+    SINGLE_ANYONECANPAY_BIP143,
+];
+
+/** List of legacy sighashes (OG Bitcoin signature) */
+export const SIG_HASH_TYPES_LEGACY = [
+    ALL_LEGACY,
+    ALL_ANYONECANPAY_LEGACY,
+    NONE_LEGACY,
+    NONE_ANYONECANPAY_LEGACY,
+    SINGLE_LEGACY,
+    SINGLE_ANYONECANPAY_LEGACY,
+];

package/src/test/testRunner.ts

@@ -0,0 +1,209 @@
+// Copyright (c) 2024 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+import type { ChronikClient } from 'chronik-client';
+import type { ChildProcess } from 'node:child_process';
+
+import { Ecc } from '../ecc.js';
+import { shaRmd160 } from '../hash.js';
+import { fromHex, toHex } from '../io/hex.js';
+import { pushBytesOp } from '../op.js';
+import { OP_1, OP_RETURN } from '../opcode.js';
+import { Script } from '../script.js';
+import { OutPoint, Tx } from '../tx.js';
+import { TxBuilder } from '../txBuilder.js';
+
+const OP_TRUE_SCRIPT = Script.fromOps([OP_1]);
+const OP_TRUE_SCRIPT_SIG = Script.fromOps([
+    pushBytesOp(OP_TRUE_SCRIPT.bytecode),
+]);
+// Like OP_TRUE_SCRIPT but much bigger to avoid undersize
+const ANYONE_SCRIPT = Script.fromOps([pushBytesOp(fromHex('01'.repeat(100)))]);
+const ANYONE_SCRIPT_SIG = Script.fromOps([pushBytesOp(ANYONE_SCRIPT.bytecode)]);
+
+export class TestRunner {
+    public ecc: Ecc;
+    public runner: ChildProcess;
+    public chronik: ChronikClient;
+    private coinsTxid: string | undefined;
+    private coinValue: number | undefined;
+    private lastUsedOutIdx: number;
+
+    private constructor(
+        ecc: Ecc,
+        runner: ChildProcess,
+        chronik: ChronikClient,
+    ) {
+        this.ecc = ecc;
+        this.runner = runner;
+        this.chronik = chronik;
+        this.coinsTxid = undefined;
+        this.lastUsedOutIdx = 0;
+    }
+
+    public static async setup(
+        setupScript: string = 'setup_scripts/ecash-lib_base',
+    ): Promise<TestRunner> {
+        const { ChronikClient } = await import('chronik-client');
+        const { spawn } = await import('node:child_process');
+        const events = await import('node:events');
+        const statusEvent = new events.EventEmitter();
+
+        const runner = spawn(
+            'python3',
+            [
+                'test/functional/test_runner.py',
+                // Place the setup in the python file
+                setupScript,
+            ],
+            {
+                stdio: ['ipc'],
+                // Needs to be set dynamically and the Bitcoin ABC
+                // node has to be built first.
+                cwd: process.env.BUILD_DIR || '.',
+            },
+        );
+
+        // Redirect stdout so we can see the messages from the test runner
+        runner.stdout?.pipe(process.stdout);
+        runner.stderr?.pipe(process.stderr);
+
+        runner.on('error', function (error) {
+            console.log('Test runner error, aborting: ' + error);
+            runner.kill();
+            process.exit(-1);
+        });
+
+        runner.on('exit', function (code, signal) {
+            // The test runner failed, make sure to propagate the error
+            if (code !== null && code !== undefined && code != 0) {
+                console.log('Test runner completed with code ' + code);
+                process.exit(code);
+            }
+
+            // The test runner was aborted by a signal, make sure to return an
+            // error
+            if (signal !== null && signal !== undefined) {
+                console.log('Test runner aborted by signal ' + signal);
+                process.exit(-2);
+            }
+
+            // In all other cases, let the test return its own status as
+            // expected
+        });
+
+        runner.on('spawn', function () {
+            console.log('Test runner started');
+        });
+
+        let chronik: ChronikClient | undefined = undefined;
+        runner.on('message', async function (message: any) {
+            if (message && message.test_info && message.test_info.chronik) {
+                console.log(
+                    'Setting chronik url to ',
+                    message.test_info.chronik,
+                );
+                chronik = new ChronikClient(message.test_info.chronik);
+            }
+
+            if (message && message.status) {
+                while (!statusEvent.emit(message.status)) {
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            }
+        });
+
+        const ecc = new Ecc();
+
+        // We got the coins, can fan out now
+        await (events as any).once(statusEvent, 'ready');
+
+        if (chronik === undefined) {
+            throw new Event('Chronik is undefined');
+        }
+
+        return new TestRunner(ecc, runner, chronik);
+    }
+
+    public async setupCoins(
+        numCoins: number,
+        coinValue: number,
+    ): Promise<void> {
+        const opTrueScriptHash = shaRmd160(OP_TRUE_SCRIPT.bytecode);
+        const utxos = (
+            await this.chronik.script('p2sh', toHex(opTrueScriptHash)).utxos()
+        ).utxos;
+        const anyoneScriptHash = shaRmd160(ANYONE_SCRIPT.bytecode);
+        const anyoneP2sh = Script.p2sh(anyoneScriptHash);
+        const tx = new Tx({
+            inputs: utxos.map(utxo => ({
+                prevOut: utxo.outpoint,
+                script: OP_TRUE_SCRIPT_SIG,
+                sequence: 0xffffffff,
+            })),
+        });
+        const utxosValue = utxos.reduce((a, b) => a + b.value, 0);
+        for (let i = 0; i < numCoins; ++i) {
+            tx.outputs.push({
+                value: coinValue,
+                script: anyoneP2sh,
+            });
+        }
+        tx.outputs.push({
+            value: 0,
+            script: Script.fromOps([OP_RETURN]),
+        });
+        tx.outputs[tx.outputs.length - 1].value =
+            utxosValue - numCoins * coinValue - tx.serSize();
+
+        this.coinsTxid = (await this.chronik.broadcastTx(tx.ser())).txid;
+        this.coinValue = coinValue;
+    }
+
+    public getOutpoint(): OutPoint {
+        if (this.coinsTxid === undefined) {
+            throw new Error('TestRunner.coinsTxid undefined, call setupCoins');
+        }
+        return {
+            txid: this.coinsTxid,
+            outIdx: this.lastUsedOutIdx++, // use value, then increment
+        };
+    }
+
+    public async sendToScript(
+        value: number | number[],
+        script: Script,
+    ): Promise<string> {
+        const coinValue = this.coinValue!;
+        const values = Array.isArray(value) ? value : [value];
+        const setupTxBuilder = new TxBuilder({
+            inputs: [
+                {
+                    input: {
+                        prevOut: this.getOutpoint(),
+                        script: ANYONE_SCRIPT_SIG,
+                        sequence: 0xffffffff,
+                        signData: {
+                            value: coinValue,
+                        },
+                    },
+                },
+            ],
+            outputs: [
+                ...values.map(value => ({ value, script })),
+                Script.fromOps([OP_RETURN]), // burn leftover
+            ],
+        });
+        const setupTx = setupTxBuilder.sign(this.ecc, 1000, 546);
+        return (await this.chronik.broadcastTx(setupTx.ser())).txid;
+    }
+
+    public generate() {
+        this.runner.send('generate');
+    }
+
+    public stop() {
+        this.runner.send('stop');
+    }
+}