@btc-vision/transaction 1.0.60 → 1.0.61

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;
+    }
+}

package/src/generators/builders/DeploymentGenerator.ts

@@ -1,66 +1,66 @@
-import { crypto, Network, networks, opcodes, script } from 'bitcoinjs-lib';
-import { Generator } from '../Generator.js';
-
-export class DeploymentGenerator extends Generator {
-    constructor(
-        senderPubKey: Buffer,
-        contractSaltPubKey: Buffer,
-        network: Network = networks.bitcoin,
-    ) {
-        super(senderPubKey, contractSaltPubKey, network);
-    }
-
-    /**
-     * Compile a bitcoin script representing a contract deployment
-     * @param {Buffer} contractBytecode - The contract bytecode
-     * @param {Buffer} contractSalt - The contract salt
-     * @returns {Buffer} - The compiled script
-     */
-    public compile(contractBytecode: Buffer, contractSalt: Buffer): Buffer {
-        const asm = this.getAsm(contractBytecode, contractSalt);
-        const compiled = script.compile(asm);
-
-        /**
-         * Verify that the script can be decompiled
-         */
-        const decompiled = script.decompile(compiled);
-        if (!decompiled) {
-            throw new Error('Failed to decompile script??');
-        }
-
-        return compiled;
-    }
-
-    private getAsm(contractBytecode: Buffer, contractSalt: Buffer): (number | Buffer)[] {
-        const dataChunks = this.splitBufferIntoChunks(contractBytecode);
-
-        return [
-            this.senderPubKey,
-            opcodes.OP_CHECKSIGVERIFY,
-
-            this.contractSaltPubKey,
-            opcodes.OP_CHECKSIGVERIFY,
-
-            opcodes.OP_HASH160,
-            crypto.hash160(this.senderPubKey),
-            opcodes.OP_EQUALVERIFY,
-
-            opcodes.OP_HASH256,
-            crypto.hash256(contractSalt),
-            opcodes.OP_EQUALVERIFY,
-
-            opcodes.OP_DEPTH,
-            opcodes.OP_1,
-            opcodes.OP_NUMEQUAL,
-            opcodes.OP_IF,
-
-            Generator.MAGIC,
-            opcodes.OP_1NEGATE,
-            ...dataChunks,
-
-            opcodes.OP_ELSE,
-            opcodes.OP_1,
-            opcodes.OP_ENDIF,
-        ].flat();
-    }
-}
+import { crypto, Network, networks, opcodes, script } from 'bitcoinjs-lib';
+import { Generator } from '../Generator.js';
+
+export class DeploymentGenerator extends Generator {
+    constructor(
+        senderPubKey: Buffer,
+        contractSaltPubKey: Buffer,
+        network: Network = networks.bitcoin,
+    ) {
+        super(senderPubKey, contractSaltPubKey, network);
+    }
+
+    /**
+     * Compile a bitcoin script representing a contract deployment
+     * @param {Buffer} contractBytecode - The contract bytecode
+     * @param {Buffer} contractSalt - The contract salt
+     * @returns {Buffer} - The compiled script
+     */
+    public compile(contractBytecode: Buffer, contractSalt: Buffer): Buffer {
+        const asm = this.getAsm(contractBytecode, contractSalt);
+        const compiled = script.compile(asm);
+
+        /**
+         * Verify that the script can be decompiled
+         */
+        const decompiled = script.decompile(compiled);
+        if (!decompiled) {
+            throw new Error('Failed to decompile script??');
+        }
+
+        return compiled;
+    }
+
+    private getAsm(contractBytecode: Buffer, contractSalt: Buffer): (number | Buffer)[] {
+        const dataChunks = this.splitBufferIntoChunks(contractBytecode);
+
+        return [
+            this.senderPubKey,
+            opcodes.OP_CHECKSIGVERIFY,
+
+            this.contractSaltPubKey,
+            opcodes.OP_CHECKSIGVERIFY,
+
+            opcodes.OP_HASH160,
+            crypto.hash160(this.senderPubKey),
+            opcodes.OP_EQUALVERIFY,
+
+            opcodes.OP_HASH256,
+            crypto.hash256(contractSalt),
+            opcodes.OP_EQUALVERIFY,
+
+            opcodes.OP_DEPTH,
+            opcodes.OP_1,
+            opcodes.OP_NUMEQUAL,
+            opcodes.OP_IF,
+
+            Generator.MAGIC,
+            opcodes.OP_1NEGATE,
+            ...dataChunks,
+
+            opcodes.OP_ELSE,
+            opcodes.OP_1,
+            opcodes.OP_ENDIF,
+        ].flat();
+    }
+}

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as opnet from './opnet.js';
-
-export { opnet };
-export * from './opnet.js';
+import * as opnet from './opnet.js';
+
+export { opnet };
+export * from './opnet.js';