@btc-vision/transaction 1.0.59 → 1.0.61

package/src/crypto/crypto-browser.js

@@ -1,75 +1,75 @@
-/* Browser Crypto Shims */
-import { hmac } from '@noble/hashes/hmac';
-import { pbkdf2 } from '@noble/hashes/pbkdf2';
-import { sha256 } from '@noble/hashes/sha256';
-import { sha512 } from '@noble/hashes/sha512';
-import assert from 'assert';
-
-function assertArgument(check, message, name, value) {
-    assert(check, message, 'INVALID_ARGUMENT', { argument: name, value: value });
-}
-
-function getGlobal() {
-    if (typeof self !== 'undefined') {
-        return self;
-    }
-    if (typeof window !== 'undefined') {
-        return window;
-    }
-    if (typeof global !== 'undefined') {
-        return global;
-    }
-    throw new Error('unable to locate global object');
-}
-
-const anyGlobal = getGlobal();
-const crypto = anyGlobal.crypto || anyGlobal.msCrypto;
-
-export function createHash(algo) {
-    switch (algo) {
-        case 'sha256':
-            return sha256.create();
-        case 'sha512':
-            return sha512.create();
-    }
-    assertArgument(false, 'invalid hashing algorithm name', 'algorithm', algo);
-}
-
-export function createHmac(_algo, key) {
-    const algo = { sha256, sha512 }[_algo];
-    assertArgument(algo != null, 'invalid hmac algorithm', 'algorithm', _algo);
-    return hmac.create(algo, key);
-}
-
-export function pbkdf2Sync(password, salt, iterations, keylen, _algo) {
-    const algo = { sha256, sha512 }[_algo];
-    assertArgument(algo != null, 'invalid pbkdf2 algorithm', 'algorithm', _algo);
-    return pbkdf2(algo, password, salt, { c: iterations, dkLen: keylen });
-}
-
-export function randomBytes(length) {
-    assert(
-        crypto != null,
-        'platform does not support secure random numbers',
-        'UNSUPPORTED_OPERATION',
-        {
-            operation: 'randomBytes',
-        },
-    );
-    assertArgument(
-        Number.isInteger(length) && length > 0 && length <= 1024,
-        'invalid length',
-        'length',
-        length,
-    );
-    const result = new Uint8Array(length);
-    crypto.getRandomValues(result);
-    return result;
-}
-
-export default {
-    createHash,
-    createHmac,
-    pbkdf2Sync,
-    randomBytes,
-};
+/* Browser Crypto Shims */
+import { hmac } from '@noble/hashes/hmac';
+import { pbkdf2 } from '@noble/hashes/pbkdf2';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import assert from 'assert';
+
+function assertArgument(check, message, name, value) {
+    assert(check, message, 'INVALID_ARGUMENT', { argument: name, value: value });
+}
+
+function getGlobal() {
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw new Error('unable to locate global object');
+}
+
+const anyGlobal = getGlobal();
+const crypto = anyGlobal.crypto || anyGlobal.msCrypto;
+
+export function createHash(algo) {
+    switch (algo) {
+        case 'sha256':
+            return sha256.create();
+        case 'sha512':
+            return sha512.create();
+    }
+    assertArgument(false, 'invalid hashing algorithm name', 'algorithm', algo);
+}
+
+export function createHmac(_algo, key) {
+    const algo = { sha256, sha512 }[_algo];
+    assertArgument(algo != null, 'invalid hmac algorithm', 'algorithm', _algo);
+    return hmac.create(algo, key);
+}
+
+export function pbkdf2Sync(password, salt, iterations, keylen, _algo) {
+    const algo = { sha256, sha512 }[_algo];
+    assertArgument(algo != null, 'invalid pbkdf2 algorithm', 'algorithm', _algo);
+    return pbkdf2(algo, password, salt, { c: iterations, dkLen: keylen });
+}
+
+export function randomBytes(length) {
+    assert(
+        crypto != null,
+        'platform does not support secure random numbers',
+        'UNSUPPORTED_OPERATION',
+        {
+            operation: 'randomBytes',
+        },
+    );
+    assertArgument(
+        Number.isInteger(length) && length > 0 && length <= 1024,
+        'invalid length',
+        'length',
+        length,
+    );
+    const result = new Uint8Array(length);
+    crypto.getRandomValues(result);
+    return result;
+}
+
+export default {
+    createHash,
+    createHmac,
+    pbkdf2Sync,
+    randomBytes,
+};

package/src/generators/AddressGenerator.ts

@@ -1,24 +1,24 @@
-import { bech32 } from 'bech32';
-import { initEccLib, Network } from 'bitcoinjs-lib';
-import * as ecc from '@bitcoinerlab/secp256k1';
-import { ripemd160 } from 'bitcoinjs-lib/src/crypto.js';
-
-initEccLib(ecc);
-
-export class AddressGenerator {
-    // Generate a valid SegWit address from random bytes
-    public static generatePKSH(sha256Hash: Buffer, network: Network): string {
-        if (sha256Hash.length !== 32) throw new Error('Invalid hash length');
-
-        const pkh = ripemd160(sha256Hash);
-        return this.toSegwitAddress(pkh, network);
-    }
-
-    // Convert a hash to a SegWit address
-    private static toSegwitAddress(pkh: Buffer, network: Network): string {
-        const words = bech32.toWords(pkh);
-        words.unshift(0x00); // Add the witness version byte (0x00 for P2WPKH)
-
-        return bech32.encode(network.bech32, words);
-    }
-}
+import { bech32 } from 'bech32';
+import { initEccLib, Network } from 'bitcoinjs-lib';
+import * as ecc from '@bitcoinerlab/secp256k1';
+import { ripemd160 } from 'bitcoinjs-lib/src/crypto.js';
+
+initEccLib(ecc);
+
+export class AddressGenerator {
+    // Generate a valid SegWit address from random bytes
+    public static generatePKSH(sha256Hash: Buffer, network: Network): string {
+        if (sha256Hash.length !== 32) throw new Error('Invalid hash length');
+
+        const pkh = ripemd160(sha256Hash);
+        return this.toSegwitAddress(pkh, network);
+    }
+
+    // Convert a hash to a SegWit address
+    private static toSegwitAddress(pkh: Buffer, network: Network): string {
+        const words = bech32.toWords(pkh);
+        words.unshift(0x00); // Add the witness version byte (0x00 for P2WPKH)
+
+        return bech32.encode(network.bech32, words);
+    }
+}

package/src/generators/Features.ts

@@ -1,5 +1,5 @@
-import { opcodes } from 'bitcoinjs-lib';
-
-export enum Features {
-    UNWRAP = opcodes.OP_16,
-}
+import { opcodes } from 'bitcoinjs-lib';
+
+export enum Features {
+    UNWRAP = opcodes.OP_16,
+}

package/src/generators/Generator.ts

@@ -1,75 +1,75 @@
-import { Network, networks } from 'bitcoinjs-lib';
-
-/** Bitcoin Script Generator */
-export abstract class Generator {
-    /**
-     * The maximum size of a data chunk
-     */
-    public static readonly DATA_CHUNK_SIZE: number = 512;
-
-    /**
-     * The magic number of OPNet
-     */
-    public static readonly MAGIC: Buffer = Buffer.from('bsi', 'utf-8');
-
-    /**
-     * The public key of the sender
-     * @protected
-     */
-    protected readonly senderPubKey: Buffer;
-
-    /**
-     * The public key of the contract salt
-     * @protected
-     */
-    protected readonly contractSaltPubKey: Buffer;
-
-    /**
-     * The network to use
-     * @protected
-     */
-    protected readonly network: Network = networks.bitcoin;
-
-    protected constructor(
-        senderPubKey: Buffer,
-        contractSaltPubKey: Buffer,
-        network: Network = networks.bitcoin,
-    ) {
-        this.senderPubKey = senderPubKey;
-        this.contractSaltPubKey = contractSaltPubKey;
-        this.network = network;
-    }
-
-    /**
-     * Compile the script
-     * @param args - The arguments to use when compiling the script
-     * @returns {Buffer} - The compiled script
-     */
-    public abstract compile(...args: unknown[]): Buffer;
-
-    /**
-     * Split a buffer into chunks
-     * @param {Buffer} buffer - The buffer to split
-     * @param {number} chunkSize - The size of each chunk
-     * @protected
-     * @returns {Array<Buffer[]>} - The chunks
-     */
-    protected splitBufferIntoChunks(
-        buffer: Buffer,
-        chunkSize: number = Generator.DATA_CHUNK_SIZE,
-    ): Array<Buffer[]> {
-        const chunks: Array<Buffer[]> = [];
-        for (let i = 0; i < buffer.length; i += chunkSize) {
-            const dataLength = Math.min(chunkSize, buffer.length - i);
-
-            const buf2 = Buffer.alloc(dataLength);
-            for (let j = 0; j < dataLength; j++) {
-                buf2.writeUInt8(buffer[i + j], j);
-            }
-
-            chunks.push([buf2]);
-        }
-
-        return chunks;
-    }
-}
+import { Network, networks } from 'bitcoinjs-lib';
+
+/** Bitcoin Script Generator */
+export abstract class Generator {
+    /**
+     * The maximum size of a data chunk
+     */
+    public static readonly DATA_CHUNK_SIZE: number = 512;
+
+    /**
+     * The magic number of OPNet
+     */
+    public static readonly MAGIC: Buffer = Buffer.from('bsi', 'utf-8');
+
+    /**
+     * The public key of the sender
+     * @protected
+     */
+    protected readonly senderPubKey: Buffer;
+
+    /**
+     * The public key of the contract salt
+     * @protected
+     */
+    protected readonly contractSaltPubKey: Buffer;
+
+    /**
+     * The network to use
+     * @protected
+     */
+    protected readonly network: Network = networks.bitcoin;
+
+    protected constructor(
+        senderPubKey: Buffer,
+        contractSaltPubKey: Buffer,
+        network: Network = networks.bitcoin,
+    ) {
+        this.senderPubKey = senderPubKey;
+        this.contractSaltPubKey = contractSaltPubKey;
+        this.network = network;
+    }
+
+    /**
+     * Compile the script
+     * @param args - The arguments to use when compiling the script
+     * @returns {Buffer} - The compiled script
+     */
+    public abstract compile(...args: unknown[]): Buffer;
+
+    /**
+     * Split a buffer into chunks
+     * @param {Buffer} buffer - The buffer to split
+     * @param {number} chunkSize - The size of each chunk
+     * @protected
+     * @returns {Array<Buffer[]>} - The chunks
+     */
+    protected splitBufferIntoChunks(
+        buffer: Buffer,
+        chunkSize: number = Generator.DATA_CHUNK_SIZE,
+    ): Array<Buffer[]> {
+        const chunks: Array<Buffer[]> = [];
+        for (let i = 0; i < buffer.length; i += chunkSize) {
+            const dataLength = Math.min(chunkSize, buffer.length - i);
+
+            const buf2 = Buffer.alloc(dataLength);
+            for (let j = 0; j < dataLength; j++) {
+                buf2.writeUInt8(buffer[i + j], j);
+            }
+
+            chunks.push([buf2]);
+        }
+
+        return chunks;
+    }
+}

package/src/generators/builders/CalldataGenerator.ts

@@ -1,148 +1,148 @@
-import { crypto, Network, networks, opcodes, script } from 'bitcoinjs-lib';
-import { ECPairInterface } from 'ecpair';
-import { Compressor } from '../../bytecode/Compressor.js';
-import { Generator } from '../Generator.js';
-import { EcKeyPair } from '../../keypair/EcKeyPair.js';
-import { Features } from '../Features.js';
-
-/**
- * Class to generate bitcoin script for interaction transactions
- */
-export class CalldataGenerator extends Generator {
-    constructor(
-        senderPubKey: Buffer,
-        contractSaltPubKey: Buffer,
-        network: Network = networks.bitcoin,
-    ) {
-        super(senderPubKey, contractSaltPubKey, network);
-    }
-
-    /**
-     * Get the public key as a buffer
-     * @param {Buffer[]} witnessKeys - The public keys
-     * @param {Network} network - The network to use
-     * @private
-     * @returns {Buffer} - The public key as a buffer
-     */
-    public static getPubKeyAsBuffer(witnessKeys: Buffer[], network: Network): Buffer {
-        let finalBuffer: Buffer = Buffer.alloc(0);
-
-        for (let pubKey of witnessKeys) {
-            const key: ECPairInterface = EcKeyPair.fromPublicKey(pubKey, network);
-
-            if (!key.compressed) {
-                throw new Error('Public key must be compressed');
-            }
-
-            if (pubKey.byteLength !== 33) {
-                throw new Error(`Public key must be 33 bytes, got ${pubKey.byteLength} bytes.`);
-            }
-
-            finalBuffer = Buffer.concat([finalBuffer, pubKey]);
-        }
-
-        // compress the public keys
-        const compressed: Buffer = Compressor.compress(finalBuffer);
-        if (compressed.byteLength >= finalBuffer.byteLength) {
-            // we ensure that the user pays the smallest amount of fees. [micro-optimization]
-            return finalBuffer;
-        }
-
-        // if compressed is smaller, return compressed.
-        return compressed;
-    }
-
-    /**
-     * Compile an interaction bitcoin script
-     * @param {Buffer} calldata - The calldata to use
-     * @param {Buffer} contractSecret - The contract secret
-     * @param {number[]} [features=[]] - The features to use (optional)
-     * @param {Buffer[]} [vaultPublicKeys=[]] - The public keys of the vault (optional)
-     * @param {number} [minimumSignatures=0] - The minimum number of signatures (optional)
-     * @returns {Buffer} - The compiled script
-     * @throws {Error} - If something goes wrong
-     */
-    public compile(
-        calldata: Buffer,
-        contractSecret: Buffer,
-        features: Features[] = [],
-        vaultPublicKeys: Buffer[] = [],
-        minimumSignatures: number = 0,
-    ): Buffer {
-        const dataChunks: Buffer[][] = this.splitBufferIntoChunks(calldata);
-        if (!dataChunks.length) throw new Error('No data chunks found');
-
-        let compiledData = [
-            this.senderPubKey,
-            opcodes.OP_CHECKSIGVERIFY,
-
-            this.contractSaltPubKey,
-            opcodes.OP_CHECKSIGVERIFY,
-
-            opcodes.OP_HASH160,
-            crypto.hash160(this.senderPubKey),
-            opcodes.OP_EQUALVERIFY,
-
-            opcodes.OP_HASH160,
-            crypto.hash160(contractSecret),
-            opcodes.OP_EQUALVERIFY,
-
-            opcodes.OP_DEPTH,
-            opcodes.OP_1,
-            opcodes.OP_NUMEQUAL,
-            opcodes.OP_IF,
-
-            Generator.MAGIC,
-        ];
-
-        // write pub keys, when requested.
-        if (vaultPublicKeys.length > 0) {
-            const pubKeyBuffer = CalldataGenerator.getPubKeyAsBuffer(vaultPublicKeys, this.network);
-            const pubKeyDataChunks: Buffer[][] = this.splitBufferIntoChunks(pubKeyBuffer);
-
-            compiledData = compiledData.concat(
-                ...[
-                    opcodes.OP_0, // provide opnet public keys
-                    ...pubKeyDataChunks,
-                ],
-            );
-
-            if (minimumSignatures) {
-                // verify that the minimum is not greater than 255
-                if (minimumSignatures > 255) {
-                    throw new Error('Minimum signatures cannot exceed 255');
-                }
-
-                // we use a 2 bytes buffer even if we limit to 255 so it does not use an opcode for the number
-                const minSigBuffer = Buffer.alloc(2);
-                minSigBuffer.writeUint16LE(minimumSignatures, 0);
-
-                compiledData = compiledData.concat(
-                    ...[
-                        opcodes.OP_1, // provide minimum signatures
-                        minSigBuffer,
-                    ],
-                );
-            } else {
-                throw new Error('Minimum signatures must be provided');
-            }
-        }
-
-        // Write calldata
-        compiledData = compiledData.concat(
-            ...features,
-            ...[opcodes.OP_1NEGATE, ...dataChunks, opcodes.OP_ELSE, opcodes.OP_1, opcodes.OP_ENDIF],
-        );
-
-        const asm = compiledData.flat();
-        const compiled = script.compile(asm);
-
-        /** Verify the validity of the script */
-        const decompiled = script.decompile(compiled);
-        if (!decompiled) {
-            throw new Error('Failed to decompile script??');
-        }
-
-        return compiled;
-    }
-}
+import { crypto, Network, networks, opcodes, script } from 'bitcoinjs-lib';
+import { ECPairInterface } from 'ecpair';
+import { Compressor } from '../../bytecode/Compressor.js';
+import { Generator } from '../Generator.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { Features } from '../Features.js';
+
+/**
+ * Class to generate bitcoin script for interaction transactions
+ */
+export class CalldataGenerator extends Generator {
+    constructor(
+        senderPubKey: Buffer,
+        contractSaltPubKey: Buffer,
+        network: Network = networks.bitcoin,
+    ) {
+        super(senderPubKey, contractSaltPubKey, network);
+    }
+
+    /**
+     * Get the public key as a buffer
+     * @param {Buffer[]} witnessKeys - The public keys
+     * @param {Network} network - The network to use
+     * @private
+     * @returns {Buffer} - The public key as a buffer
+     */
+    public static getPubKeyAsBuffer(witnessKeys: Buffer[], network: Network): Buffer {
+        let finalBuffer: Buffer = Buffer.alloc(0);
+
+        for (let pubKey of witnessKeys) {
+            const key: ECPairInterface = EcKeyPair.fromPublicKey(pubKey, network);
+
+            if (!key.compressed) {
+                throw new Error('Public key must be compressed');
+            }
+
+            if (pubKey.byteLength !== 33) {
+                throw new Error(`Public key must be 33 bytes, got ${pubKey.byteLength} bytes.`);
+            }
+
+            finalBuffer = Buffer.concat([finalBuffer, pubKey]);
+        }
+
+        // compress the public keys
+        const compressed: Buffer = Compressor.compress(finalBuffer);
+        if (compressed.byteLength >= finalBuffer.byteLength) {
+            // we ensure that the user pays the smallest amount of fees. [micro-optimization]
+            return finalBuffer;
+        }
+
+        // if compressed is smaller, return compressed.
+        return compressed;
+    }
+
+    /**
+     * Compile an interaction bitcoin script
+     * @param {Buffer} calldata - The calldata to use
+     * @param {Buffer} contractSecret - The contract secret
+     * @param {number[]} [features=[]] - The features to use (optional)
+     * @param {Buffer[]} [vaultPublicKeys=[]] - The public keys of the vault (optional)
+     * @param {number} [minimumSignatures=0] - The minimum number of signatures (optional)
+     * @returns {Buffer} - The compiled script
+     * @throws {Error} - If something goes wrong
+     */
+    public compile(
+        calldata: Buffer,
+        contractSecret: Buffer,
+        features: Features[] = [],
+        vaultPublicKeys: Buffer[] = [],
+        minimumSignatures: number = 0,
+    ): Buffer {
+        const dataChunks: Buffer[][] = this.splitBufferIntoChunks(calldata);
+        if (!dataChunks.length) throw new Error('No data chunks found');
+
+        let compiledData = [
+            this.senderPubKey,
+            opcodes.OP_CHECKSIGVERIFY,
+
+            this.contractSaltPubKey,
+            opcodes.OP_CHECKSIGVERIFY,
+
+            opcodes.OP_HASH160,
+            crypto.hash160(this.senderPubKey),
+            opcodes.OP_EQUALVERIFY,
+
+            opcodes.OP_HASH160,
+            crypto.hash160(contractSecret),
+            opcodes.OP_EQUALVERIFY,
+
+            opcodes.OP_DEPTH,
+            opcodes.OP_1,
+            opcodes.OP_NUMEQUAL,
+            opcodes.OP_IF,
+
+            Generator.MAGIC,
+        ];
+
+        // write pub keys, when requested.
+        if (vaultPublicKeys.length > 0) {
+            const pubKeyBuffer = CalldataGenerator.getPubKeyAsBuffer(vaultPublicKeys, this.network);
+            const pubKeyDataChunks: Buffer[][] = this.splitBufferIntoChunks(pubKeyBuffer);
+
+            compiledData = compiledData.concat(
+                ...[
+                    opcodes.OP_0, // provide opnet public keys
+                    ...pubKeyDataChunks,
+                ],
+            );
+
+            if (minimumSignatures) {
+                // verify that the minimum is not greater than 255
+                if (minimumSignatures > 255) {
+                    throw new Error('Minimum signatures cannot exceed 255');
+                }
+
+                // we use a 2 bytes buffer even if we limit to 255 so it does not use an opcode for the number
+                const minSigBuffer = Buffer.alloc(2);
+                minSigBuffer.writeUint16LE(minimumSignatures, 0);
+
+                compiledData = compiledData.concat(
+                    ...[
+                        opcodes.OP_1, // provide minimum signatures
+                        minSigBuffer,
+                    ],
+                );
+            } else {
+                throw new Error('Minimum signatures must be provided');
+            }
+        }
+
+        // Write calldata
+        compiledData = compiledData.concat(
+            ...features,
+            ...[opcodes.OP_1NEGATE, ...dataChunks, opcodes.OP_ELSE, opcodes.OP_1, opcodes.OP_ENDIF],
+        );
+
+        const asm = compiledData.flat();
+        const compiled = script.compile(asm);
+
+        /** Verify the validity of the script */
+        const decompiled = script.decompile(compiled);
+        if (!decompiled) {
+            throw new Error('Failed to decompile script??');
+        }
+
+        return compiled;
+    }
+}