@btc-vision/transaction 1.0.85 → 1.0.86

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';

package/src/keypair/AddressVerificator.ts

@@ -1,40 +1,40 @@
-import { address, initEccLib, networks } from 'bitcoinjs-lib';
-import * as ecc from '@bitcoinerlab/secp256k1';
-import { Address } from '@btc-vision/bsi-binary';
-
-initEccLib(ecc);
-
-export class AddressVerificator {
-    public static isValidP2TRAddress(inAddress: Address, network: networks.Network): boolean {
-        if (!inAddress || inAddress.length < 50) return false;
-
-        let isValidTapRootAddress: boolean = false;
-        try {
-            address.toOutputScript(inAddress, network);
-
-            const decodedAddress = address.fromBech32(inAddress);
-            isValidTapRootAddress = decodedAddress.version === 1;
-        } catch (e) {}
-
-        return isValidTapRootAddress;
-    }
-
-    public static validatePKHAddress(inAddress: string, network: networks.Network): boolean {
-        if (!inAddress || inAddress.length < 20 || inAddress.length > 50) return false;
-
-        let isValidSegWitAddress: boolean = false;
-        try {
-            // Decode the address using Bech32
-            const decodedAddress = address.fromBech32(inAddress);
-
-            // Ensure the decoded address matches the provided network
-            address.toOutputScript(inAddress, network);
-
-            // Check if the address is P2WPKH (version 0)
-            isValidSegWitAddress =
-                decodedAddress.version === 0 && decodedAddress.data.length === 20;
-        } catch (e) {}
-
-        return isValidSegWitAddress;
-    }
-}
+import { address, initEccLib, networks } from 'bitcoinjs-lib';
+import * as ecc from '@bitcoinerlab/secp256k1';
+import { Address } from '@btc-vision/bsi-binary';
+
+initEccLib(ecc);
+
+export class AddressVerificator {
+    public static isValidP2TRAddress(inAddress: Address, network: networks.Network): boolean {
+        if (!inAddress || inAddress.length < 50) return false;
+
+        let isValidTapRootAddress: boolean = false;
+        try {
+            address.toOutputScript(inAddress, network);
+
+            const decodedAddress = address.fromBech32(inAddress);
+            isValidTapRootAddress = decodedAddress.version === 1;
+        } catch (e) {}
+
+        return isValidTapRootAddress;
+    }
+
+    public static validatePKHAddress(inAddress: string, network: networks.Network): boolean {
+        if (!inAddress || inAddress.length < 20 || inAddress.length > 50) return false;
+
+        let isValidSegWitAddress: boolean = false;
+        try {
+            // Decode the address using Bech32
+            const decodedAddress = address.fromBech32(inAddress);
+
+            // Ensure the decoded address matches the provided network
+            address.toOutputScript(inAddress, network);
+
+            // Check if the address is P2WPKH (version 0)
+            isValidSegWitAddress =
+                decodedAddress.version === 0 && decodedAddress.data.length === 20;
+        } catch (e) {}
+
+        return isValidSegWitAddress;
+    }
+}