@btc-vision/btc-runtime 1.8.1 → 1.9.1

package/runtime/script/BitcoinAddresses.ts

@@ -0,0 +1,208 @@
+import { CsvP2wshResult, MultisigP2wshResult } from './ScriptUtils';
+import { Segwit } from './Segwit';
+import { BitcoinScript } from './Script';
+import { sha256 } from '../env/global';
+
+/**
+ * Ct provides constant-time comparison functions
+ * This is important for cryptographic operations to avoid timing attacks
+ */
+@final
+export class Ct {
+    /**
+     * Compare two 32-byte arrays in constant time
+     * Returns true if they are equal, false otherwise
+     *
+     * The function always takes the same amount of time regardless of where
+     * the arrays differ, which prevents timing-based attacks
+     */
+    @inline public static eq32(a: Uint8Array, b: Uint8Array): bool {
+        // XOR the lengths with 32 to detect length mismatches
+        let d: i32 = (a.length ^ 32) | (b.length ^ 32);
+
+        // Compare each byte, accumulating differences in d
+        for (let i = 0; i < 32; i++) {
+            // Handle arrays shorter than 32 bytes by treating missing bytes as 0
+            const ai: u8 = i < a.length ? a[i] : 0;
+            const bi: u8 = i < b.length ? b[i] : 0;
+            // XOR accumulates any differences without early exit
+            d |= ai ^ bi;
+        }
+
+        // d will be 0 only if all bytes matched
+        return d == 0;
+    }
+}
+
+/**
+ * BitcoinAddresses provides high-level functions for creating and verifying
+ * various types of Bitcoin addresses, particularly those using witness scripts
+ */
+@final
+export class BitcoinAddresses {
+    /**
+     * Create a witness script for a CSV (CheckSequenceVerify) timelock
+     * This script requires a certain number of blocks to pass before spending
+     *
+     * @param pubkey - The public key that can spend after the timelock
+     * @param csvBlocks - Number of blocks to wait (must be 0-65535)
+     * @returns The witness script bytes
+     */
+    public static csvWitnessScript(pubkey: Uint8Array, csvBlocks: i32): Uint8Array {
+        return BitcoinScript.csvTimelock(pubkey, csvBlocks);
+    }
+
+    /**
+     * Create a P2WSH (Pay to Witness Script Hash) address with CSV timelock
+     * This creates both the address and the witness script needed to spend it
+     *
+     * @param pubkey - The public key that can spend after the timelock
+     * @param csvBlocks - Number of blocks to wait
+     * @param hrp - Human-readable part for the address (e.g., "bc" for mainnet)
+     * @returns Object containing both the address and witness script
+     */
+    public static csvP2wshAddress(pubkey: Uint8Array, csvBlocks: i32, hrp: string): CsvP2wshResult {
+        const ws = BitcoinAddresses.csvWitnessScript(pubkey, csvBlocks);
+        const addr = Segwit.p2wsh(hrp, ws);
+        return new CsvP2wshResult(addr, ws);
+    }
+
+    /**
+     * Verify that a given address corresponds to a specific CSV timelock setup
+     * This is useful for validating that an address was created with expected parameters
+     *
+     * @param pubkey - The expected public key
+     * @param csvBlocks - The expected number of CSV blocks
+     * @param address - The address to verify
+     * @param hrp - Expected human-readable part
+     * @param strictMinimal - Whether to enforce strict minimal encoding rules
+     * @returns true if the address matches the expected parameters
+     */
+    public static verifyCsvP2wshAddress(
+        pubkey: Uint8Array,
+        csvBlocks: i32,
+        address: string,
+        hrp: string,
+        strictMinimal: bool = true,
+    ): bool {
+        // Try to decode the address - this replaces the try-catch block
+        const dec = Segwit.decodeOrNull(address);
+        if (!dec) return false;
+
+        // Verify it's a v0 witness program with 32-byte hash
+        if (dec.version != 0 || dec.hrp != hrp || dec.program.length != 32) return false;
+
+        // Reconstruct the witness script and verify it matches
+        const ws = BitcoinAddresses.csvWitnessScript(pubkey, csvBlocks);
+
+        // Parse the witness script to ensure it's well-formed
+        const rec = BitcoinScript.recognizeCsvTimelock(ws, strictMinimal);
+        if (!rec.ok || rec.csvBlocks != csvBlocks) return false;
+
+        // Compute the script hash and compare with the address program
+        const prog = sha256(ws);
+        return Ct.eq32(dec.program, prog);
+    }
+
+    /**
+     * Create a witness script for a multisig setup
+     * This creates a script requiring m-of-n signatures to spend
+     *
+     * @param m - Number of required signatures
+     * @param pubkeys - Array of public keys (n total)
+     * @returns The witness script bytes
+     */
+    public static multisigWitnessScript(m: i32, pubkeys: Array<Uint8Array>): Uint8Array {
+        return BitcoinScript.multisig(m, pubkeys);
+    }
+
+    /**
+     * Create a P2WSH multisig address
+     * This creates both the address and the witness script for a multisig setup
+     *
+     * @param m - Number of required signatures
+     * @param pubkeys - Array of public keys
+     * @param hrp - Human-readable part for the address
+     * @returns Object containing both the address and witness script
+     */
+    public static multisigP2wshAddress(
+        m: i32,
+        pubkeys: Array<Uint8Array>,
+        hrp: string,
+    ): MultisigP2wshResult {
+        const ws = BitcoinAddresses.multisigWitnessScript(m, pubkeys);
+        const addr = Segwit.p2wsh(hrp, ws);
+        return new MultisigP2wshResult(addr, ws);
+    }
+
+    /**
+     * Verify that a given address corresponds to a specific multisig setup
+     * This validates that an address was created with the expected m-of-n parameters
+     *
+     * @param m - Expected number of required signatures
+     * @param pubkeys - Expected array of public keys
+     * @param address - The address to verify
+     * @param hrp - Expected human-readable part
+     * @returns true if the address matches the expected parameters
+     */
+    public static verifyMultisigP2wshAddress(
+        m: i32,
+        pubkeys: Array<Uint8Array>,
+        address: string,
+        hrp: string,
+    ): bool {
+        // Decode the address safely
+        const dec = Segwit.decodeOrNull(address);
+        if (!dec) return false;
+
+        // Verify it's a v0 witness program with 32-byte hash
+        if (dec.version != 0 || dec.hrp != hrp || dec.program.length != 32) return false;
+
+        // Reconstruct the witness script and compare
+        const ws = BitcoinAddresses.multisigWitnessScript(m, pubkeys);
+        const prog = sha256(ws);
+        return Ct.eq32(dec.program, prog);
+    }
+
+    /**
+     * Create a Taproot (P2TR) key-path spend address
+     * This is the simplest form of Taproot address, spendable with a single key
+     *
+     * @param outputKeyX32 - The 32-byte X coordinate of the output key
+     * @param hrp - Human-readable part for the address
+     * @returns The Bech32m-encoded address
+     */
+    public static p2trKeyPathAddress(outputKeyX32: Uint8Array, hrp: string): string {
+        return Segwit.p2tr(hrp, outputKeyX32);
+    }
+
+    /**
+     * Create a Pay-to-Witness-Public-Key-Hash (P2WPKH) address
+     * @param pubkey - The public key (33 bytes compressed or 65 bytes uncompressed)
+     * @param hrp - Human-readable part (e.g., "bc" for mainnet)
+     * @returns The Bech32-encoded address
+     */
+    public static p2wpkh(pubkey: Uint8Array, hrp: string): string {
+        return Segwit.p2wpkh(hrp, pubkey);
+    }
+
+    /**
+     * Verify that a given address corresponds to a specific Taproot output key
+     *
+     * @param outputKeyX32 - The expected 32-byte X coordinate
+     * @param address - The address to verify
+     * @param hrp - Expected human-readable part
+     * @returns true if the address matches the expected output key
+     */
+    public static verifyP2trAddress(outputKeyX32: Uint8Array, address: string, hrp: string): bool {
+        // Decode the address safely
+        const dec = Segwit.decodeOrNull(address);
+        if (!dec) return false;
+
+        // Verify it's a v1 witness program with 32-byte key
+        if (dec.version != 1 || dec.hrp != hrp || dec.program.length != 32) return false;
+
+        // Compare the output key
+        return Ct.eq32(dec.program, outputKeyX32);
+    }
+}

package/runtime/script/BitcoinCodec.ts

@@ -0,0 +1,395 @@
+import { BitcoinAddresses, Ct } from './BitcoinAddresses';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { BytesReader } from '../buffer/BytesReader';
+import { CsvPairCrossCheck, MultisigPairCrossCheck } from './ScriptUtils';
+import { Segwit } from './Segwit';
+import { sha256 } from '../env/global';
+import { BitcoinScript } from './Script';
+import { Revert } from '../types/Revert';
+
+/**
+ * Result type for codec operations that can fail
+ * This provides detailed error information when operations fail
+ */
+@final
+export class CodecResult<T> {
+    public readonly success: bool;
+    public readonly value: T | null;
+    public readonly error: string | null;
+
+    public constructor(success: bool, value: T | null, error: string | null) {
+        this.success = success;
+        this.value = value;
+        this.error = error;
+    }
+
+    public static ok<T>(value: T): CodecResult<T> {
+        return new CodecResult<T>(true, value, null);
+    }
+
+    public static err<T>(error: string): CodecResult<T> {
+        return new CodecResult<T>(false, null, error);
+    }
+}
+
+/**
+ * Represents a verified address read from a byte stream
+ */
+@final
+export class VerifiedAddress {
+    public readonly address: string;
+    public readonly witnessScript: Uint8Array | null;
+
+    constructor(address: string, witnessScript: Uint8Array | null = null) {
+        this.address = address;
+        this.witnessScript = witnessScript;
+    }
+}
+
+/**
+ * BitcoinCodec provides serialization and deserialization functions for
+ * various Bitcoin address types and witness scripts. All methods use
+ * explicit error handling suitable for AssemblyScript/WebAssembly.
+ */
+@final
+export class BitcoinCodec {
+    /**
+     * Write a CSV P2WSH address and witness script to a byte stream
+     *
+     * @param out - The output writer to write to
+     * @param pubkey - The public key for the CSV timelock
+     * @param csvBlocks - Number of blocks for the timelock
+     * @param hrp - Human-readable part for the address
+     */
+    public static writeCsvP2wsh(
+        out: BytesWriter,
+        pubkey: Uint8Array,
+        csvBlocks: i32,
+        hrp: string,
+    ): void {
+        const res = BitcoinAddresses.csvP2wshAddress(pubkey, csvBlocks, hrp);
+        out.writeStringWithLength(res.address);
+        out.writeBytesWithLength(res.witnessScript);
+    }
+
+    /**
+     * Read a CSV P2WSH address and verify it matches expected parameters
+     *
+     * @param inp - The input reader to read from
+     * @param pubkey - The expected public key
+     * @param csvBlocks - The expected CSV blocks
+     * @param hrp - The expected human-readable part
+     * @param strictMinimal - Whether to enforce strict minimal encoding
+     * @returns A result containing the verified address or an error
+     */
+    public static readAndVerifyCsvP2wsh(
+        inp: BytesReader,
+        pubkey: Uint8Array,
+        csvBlocks: i32,
+        hrp: string,
+        strictMinimal: bool = true,
+    ): CodecResult<VerifiedAddress> {
+        const addr = inp.readStringWithLength();
+
+        if (BitcoinAddresses.verifyCsvP2wshAddress(pubkey, csvBlocks, addr, hrp, strictMinimal)) {
+            const ws = BitcoinAddresses.csvWitnessScript(pubkey, csvBlocks);
+            return CodecResult.ok<VerifiedAddress>(new VerifiedAddress(addr, ws));
+        }
+
+        return CodecResult.err<VerifiedAddress>(
+            'CSV P2WSH verification failed: address does not match expected parameters',
+        );
+    }
+
+    /**
+     * Write a multisig P2WSH address and witness script to a byte stream
+     *
+     * @param out - The output writer
+     * @param m - Number of required signatures
+     * @param pubkeys - Array of public keys
+     * @param hrp - Human-readable part for the address
+     */
+    public static writeMultisigP2wsh(
+        out: BytesWriter,
+        m: i32,
+        pubkeys: Array<Uint8Array>,
+        hrp: string,
+    ): void {
+        const res = BitcoinAddresses.multisigP2wshAddress(m, pubkeys, hrp);
+        out.writeStringWithLength(res.address);
+        out.writeBytesWithLength(res.witnessScript);
+    }
+
+    /**
+     * Read and verify a multisig P2WSH address
+     *
+     * @param inp - The input reader
+     * @param m - Expected number of required signatures
+     * @param pubkeys - Expected array of public keys
+     * @param hrp - Expected human-readable part
+     * @returns A result containing the verified address or an error
+     */
+    public static readAndVerifyMultisigP2wsh(
+        inp: BytesReader,
+        m: i32,
+        pubkeys: Array<Uint8Array>,
+        hrp: string,
+    ): CodecResult<VerifiedAddress> {
+        const addr = inp.readStringWithLength();
+
+        if (BitcoinAddresses.verifyMultisigP2wshAddress(m, pubkeys, addr, hrp)) {
+            const ws = BitcoinAddresses.multisigWitnessScript(m, pubkeys);
+            return CodecResult.ok<VerifiedAddress>(new VerifiedAddress(addr, ws));
+        }
+
+        return CodecResult.err<VerifiedAddress>(
+            'Multisig P2WSH verification failed: address does not match expected parameters',
+        );
+    }
+
+    /**
+     * Write a Taproot address to a byte stream
+     *
+     * @param out - The output writer
+     * @param outputKeyX32 - The 32-byte X coordinate of the output key
+     * @param hrp - Human-readable part for the address
+     */
+    public static writeP2tr(out: BytesWriter, outputKeyX32: Uint8Array, hrp: string): void {
+        const addr = BitcoinAddresses.p2trKeyPathAddress(outputKeyX32, hrp);
+        out.writeStringWithLength(addr);
+    }
+
+    /**
+     * Read and verify a Taproot address
+     *
+     * @param inp - The input reader
+     * @param outputKeyX32 - Expected 32-byte X coordinate
+     * @param hrp - Expected human-readable part
+     * @returns A result containing the verified address or an error
+     */
+    public static readAndVerifyP2tr(
+        inp: BytesReader,
+        outputKeyX32: Uint8Array,
+        hrp: string,
+    ): CodecResult<VerifiedAddress> {
+        const addr = inp.readStringWithLength();
+
+        if (BitcoinAddresses.verifyP2trAddress(outputKeyX32, addr, hrp)) {
+            return CodecResult.ok<VerifiedAddress>(new VerifiedAddress(addr));
+        }
+
+        return CodecResult.err<VerifiedAddress>(
+            'P2TR verification failed: address does not match expected output key',
+        );
+    }
+
+    /**
+     * Read a P2WSH address/witness script pair and verify they match
+     *
+     * @param inp - The input reader
+     * @param hrp - Expected human-readable part
+     * @returns A result containing verification details
+     */
+    public static readP2wshPairAndVerify(
+        inp: BytesReader,
+        hrp: string,
+    ): CodecResult<VerifiedAddress> {
+        const address = inp.readStringWithLength();
+        const witnessScript = inp.readBytesWithLength();
+
+        // Decode the address
+        const dec = Segwit.decodeOrNull(address);
+        if (!dec) {
+            return CodecResult.err<VerifiedAddress>('Failed to decode address');
+        }
+
+        // Verify it's a valid P2WSH address
+        if (dec.version != 0) {
+            return CodecResult.err<VerifiedAddress>('Invalid witness version: expected v0');
+        }
+
+        if (dec.hrp != hrp) {
+            return CodecResult.err<VerifiedAddress>(
+                `HRP mismatch: expected ${hrp}, got ${dec.hrp}`,
+            );
+        }
+
+        if (dec.program.length != 32) {
+            return CodecResult.err<VerifiedAddress>(
+                'Invalid program length: P2WSH must be 32 bytes',
+            );
+        }
+
+        // Verify the witness script hashes to the witness program
+        const prog = sha256(witnessScript);
+        if (!Ct.eq32(dec.program, prog)) {
+            return CodecResult.err<VerifiedAddress>('Witness script hash mismatch');
+        }
+
+        return CodecResult.ok<VerifiedAddress>(new VerifiedAddress(address, witnessScript));
+    }
+
+    /**
+     * Read a CSV P2WSH pair and cross-check all components
+     *
+     * @param inp - The input reader
+     * @param hrp - Expected human-readable part
+     * @param strictMinimal - Whether to enforce strict minimal encoding
+     * @returns Detailed cross-check results including extracted parameters
+     */
+    public static readCsvP2wshPairAndCrossCheck(
+        inp: BytesReader,
+        hrp: string,
+        strictMinimal: bool = true,
+    ): CsvPairCrossCheck {
+        const address = inp.readStringWithLength();
+        const witnessScript = inp.readBytesWithLength();
+
+        // Decode the address
+        const dec = Segwit.decodeOrNull(address);
+        if (!dec) {
+            return new CsvPairCrossCheck(false, address, witnessScript, -1, null);
+        }
+
+        // Verify it's a valid P2WSH address
+        if (dec.version != 0 || dec.hrp != hrp || dec.program.length != 32) {
+            return new CsvPairCrossCheck(false, address, witnessScript, -1, null);
+        }
+
+        // Verify the witness script hashes to the witness program
+        const prog = sha256(witnessScript);
+        if (!Ct.eq32(dec.program, prog)) {
+            return new CsvPairCrossCheck(false, address, witnessScript, -1, null);
+        }
+
+        // Parse the witness script to extract CSV parameters
+        const rec = BitcoinScript.recognizeCsvTimelock(witnessScript, strictMinimal);
+        if (!rec.ok) {
+            return new CsvPairCrossCheck(false, address, witnessScript, -1, null);
+        }
+
+        // Everything checks out
+        return new CsvPairCrossCheck(true, address, witnessScript, rec.csvBlocks, rec.pubkey);
+    }
+
+    /**
+     * Read a multisig P2WSH pair and cross-check all components
+     *
+     * @param inp - The input reader
+     * @param hrp - Expected human-readable part
+     * @param expectedM - Optional: verify the m value matches
+     * @param expectedPubkeys - Optional: verify the public keys match
+     * @param strictMinimal - Whether to enforce strict minimal encoding
+     * @returns Detailed cross-check results
+     */
+    public static readMultisigP2wshPairAndCrossCheck(
+        inp: BytesReader,
+        hrp: string,
+        expectedM: i32 = -1,
+        expectedPubkeys: Array<Uint8Array> | null = null,
+        strictMinimal: bool = true,
+    ): MultisigPairCrossCheck {
+        const address = inp.readStringWithLength();
+        const witnessScript = inp.readBytesWithLength();
+
+        // Decode the address
+        const dec = Segwit.decodeOrNull(address);
+        if (!dec) {
+            return new MultisigPairCrossCheck(false, 0, 0, address);
+        }
+
+        // Verify it's a valid P2WSH address
+        if (dec.version != 0 || dec.hrp != hrp || dec.program.length != 32) {
+            return new MultisigPairCrossCheck(false, 0, 0, address);
+        }
+
+        // Verify the witness script hashes to the witness program
+        const prog = sha256(witnessScript);
+        if (!Ct.eq32(dec.program, prog)) {
+            return new MultisigPairCrossCheck(false, 0, 0, address);
+        }
+
+        // Parse the witness script to extract multisig parameters
+        const rec = BitcoinScript.recognizeMultisig(witnessScript, strictMinimal);
+        if (!rec.ok) {
+            return new MultisigPairCrossCheck(false, 0, 0, address);
+        }
+
+        // Check if m matches expected value (if provided)
+        if (expectedM >= 0 && rec.m != expectedM) {
+            return new MultisigPairCrossCheck(false, rec.m, rec.n, address);
+        }
+
+        // Check if public keys match expected values (if provided)
+        if (expectedPubkeys !== null) {
+            if (!rec.pubkeys) throw new Revert('Public keys not found in multisig script');
+
+            if (!BitcoinCodec.comparePublicKeyArrays(rec.pubkeys, expectedPubkeys)) {
+                return new MultisigPairCrossCheck(false, rec.m, rec.n, address);
+            }
+        }
+
+        // All checks passed
+        return new MultisigPairCrossCheck(true, rec.m, rec.n, address);
+    }
+
+    /**
+     * Write a generic witness script and its address
+     *
+     * @param out - The output writer
+     * @param witnessScript - The witness script bytes
+     * @param hrp - Human-readable part for the address
+     */
+    public static writeWitnessScriptAndAddress(
+        out: BytesWriter,
+        witnessScript: Uint8Array,
+        hrp: string,
+    ): void {
+        const address = Segwit.p2wsh(hrp, witnessScript);
+        out.writeStringWithLength(address);
+        out.writeBytesWithLength(witnessScript);
+    }
+
+    /**
+     * Validate that a witness script is within size limits
+     * Bitcoin consensus rules limit witness scripts to 10,000 bytes
+     *
+     * @param witnessScript - The script to validate
+     * @returns true if the script is within limits
+     */
+    public static isValidWitnessScriptSize(witnessScript: Uint8Array): bool {
+        return witnessScript.length <= 10000;
+    }
+
+    /**
+     * Compare two arrays of public keys for equality
+     * Uses constant-time comparison for each key
+     *
+     * @param a - First array of public keys
+     * @param b - Second array of public keys
+     * @returns true if arrays are identical
+     */
+    private static comparePublicKeyArrays(a: Array<Uint8Array>, b: Array<Uint8Array>): bool {
+        // Check array lengths first
+        if (a.length != b.length) return false;
+
+        // Compare each key
+        for (let i = 0; i < a.length; i++) {
+            const keyA = a[i];
+            const keyB = b[i];
+
+            // Check key lengths
+            if (keyA.length != keyB.length) return false;
+
+            // Constant-time byte comparison
+            let diff = 0;
+            for (let j = 0; j < keyA.length; j++) {
+                diff |= keyA[j] ^ keyB[j];
+            }
+
+            if (diff != 0) return false;
+        }
+
+        return true;
+    }
+}

package/runtime/script/Networks.ts

@@ -0,0 +1,94 @@
+import { Revert } from '../types/Revert';
+
+export enum Networks {
+    Unknown = -1,
+    Mainnet = 0,
+    Testnet = 1,
+    Regtest = 2,
+}
+
+@final
+export class NetworkManager {
+    private readonly mainnet: Uint8Array;
+    private readonly testnet: Uint8Array;
+    private readonly regtest: Uint8Array;
+
+    constructor() {
+        const mainnet = new Uint8Array(32);
+        mainnet.set([
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0xd6, 0x68, 0x9c, 0x08, 0x5a, 0xe1, 0x65, 0x83,
+            0x1e, 0x93, 0x4f, 0xf7, 0x63, 0xae, 0x46, 0xa2, 0xa6, 0xc1, 0x72, 0xb3, 0xf1, 0xb6,
+            0x0a, 0x8c, 0xe2, 0x6f,
+        ]);
+
+        const testnet = new Uint8Array(32);
+        testnet.set([
+            0x00, 0x00, 0x00, 0x00, 0x09, 0x33, 0xea, 0x01, 0xad, 0x0e, 0xe9, 0x84, 0x20, 0x97,
+            0x79, 0xba, 0xae, 0xc3, 0xce, 0xd9, 0x0f, 0xa3, 0xf4, 0x08, 0x71, 0x95, 0x26, 0xf8,
+            0xd7, 0x7f, 0x49, 0x43,
+        ]);
+
+        const regtest = new Uint8Array(32);
+        regtest.set([
+            0x0f, 0x91, 0x88, 0xf1, 0x3c, 0xb7, 0xb2, 0xc7, 0x1f, 0x2a, 0x33, 0x5e, 0x3a, 0x4f,
+            0xc3, 0x28, 0xbf, 0x5b, 0xeb, 0x43, 0x60, 0x12, 0xaf, 0xca, 0x59, 0x0b, 0x1a, 0x11,
+            0x46, 0x6e, 0x22, 0x06,
+        ]);
+
+        this.mainnet = mainnet;
+        this.testnet = testnet;
+        this.regtest = regtest;
+    }
+
+    public hrp(n: Networks): string {
+        switch (n) {
+            case Networks.Mainnet:
+                return 'bc';
+            case Networks.Testnet:
+                return 'tb';
+            case Networks.Regtest:
+                return 'bcrt';
+            default:
+                throw new Revert('Unknown network');
+        }
+    }
+
+    public getChainId(network: Networks): Uint8Array {
+        const out = new Uint8Array(32);
+        switch (network) {
+            case Networks.Mainnet:
+                out.set(this.mainnet);
+                return out;
+            case Networks.Testnet:
+                out.set(this.testnet);
+                return out;
+            case Networks.Regtest:
+                out.set(this.regtest);
+                return out;
+            default:
+                throw new Revert('Unknown network');
+        }
+    }
+
+    public fromChainId(chainId: Uint8Array): Networks {
+        if (chainId.length !== 32) {
+            throw new Revert('Invalid chain id length');
+        }
+
+        if (this.equals(chainId, this.mainnet)) return Networks.Mainnet;
+        if (this.equals(chainId, this.testnet)) return Networks.Testnet;
+        if (this.equals(chainId, this.regtest)) return Networks.Regtest;
+
+        throw new Revert('Unknown chain id');
+    }
+
+    private equals(a: Uint8Array, b: Uint8Array): boolean {
+        if (a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) return false;
+        }
+        return true;
+    }
+}
+
+export const Network: NetworkManager = new NetworkManager();