@btc-vision/transaction 1.0.0

package/src/generators/Generator.ts

@@ -0,0 +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;
+    }
+}

package/src/generators/builders/CalldataGenerator.ts

@@ -0,0 +1,143 @@
+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';
+
+/**
+ * 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);
+    }
+
+    /**
+     * Compile an interaction bitcoin script
+     * @param {Buffer} calldata - The calldata to use
+     * @param {Buffer} contractSecret - The contract secret
+     * @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,
+        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 = this.getPubKeyAsBuffer(vaultPublicKeys);
+            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(
+            ...[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;
+    }
+
+    /**
+     * Get the public key as a buffer
+     * @param {Buffer[]} witnessKeys - The public keys
+     * @private
+     * @returns {Buffer} - The public key as a buffer
+     */
+    private getPubKeyAsBuffer(witnessKeys: Buffer[]): Buffer {
+        let finalBuffer: Buffer = Buffer.alloc(0);
+
+        for (let pubKey of witnessKeys) {
+            const key: ECPairInterface = EcKeyPair.fromPublicKey(pubKey, this.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;
+    }
+}

package/src/generators/builders/DeploymentGenerator.ts

@@ -0,0 +1,63 @@
+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 dataChunks = this.splitBufferIntoChunks(contractBytecode);
+
+        const asm = [
+            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();
+
+        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;
+    }
+}

package/src/index.ts

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

package/src/keypair/EcKeyPair.ts

@@ -0,0 +1,265 @@
+import bip32, { BIP32Interface } from 'bip32';
+import { address, initEccLib, Network, networks, payments } from 'bitcoinjs-lib';
+import { ECPairFactory, ECPairInterface } from 'ecpair';
+import * as ecc from 'tiny-secp256k1';
+import { Address } from '@btc-vision/bsi-binary';
+import { IWallet } from './interfaces/IWallet.js';
+
+initEccLib(ecc);
+
+// @ts-ignore
+const BIP32Factory = typeof bip32 === 'function' ? bip32 : bip32.BIP32Factory;
+
+/**
+ * Class for handling EC key pairs
+ * @class EcKeyPair
+ * @module EcKeyPair
+ * @typicalname EcKeyPair
+ * @example import { EcKeyPair } from '@btc-vision/transaction';
+ */
+export class EcKeyPair {
+    // @ts-ignore
+    public static BIP32 = BIP32Factory(ecc);
+    public static ECPair = ECPairFactory(ecc);
+
+    /**
+     * Generate a keypair from a WIF
+     * @param {string} wif - The WIF to use
+     * @param {Network} network - The network to use
+     * @returns {ECPairInterface} - The generated keypair
+     */
+    public static fromWIF(wif: string, network: Network = networks.bitcoin): ECPairInterface {
+        return this.ECPair.fromWIF(wif, network);
+    }
+
+    /**
+     * Generate a keypair from a private key
+     * @param {Buffer} privateKey - The private key to use
+     * @param {Network} network - The network to use
+     * @returns {ECPairInterface} - The generated keypair
+     */
+    public static fromPrivateKey(
+        privateKey: Buffer,
+        network: Network = networks.bitcoin,
+    ): ECPairInterface {
+        return this.ECPair.fromPrivateKey(privateKey, { network });
+    }
+
+    /**
+     * Generate a keypair from a public key
+     * @param {Buffer} publicKey - The public key to use
+     * @param {Network} network - The network to use
+     * @returns {ECPairInterface} - The generated keypair
+     */
+    public static fromPublicKey(
+        publicKey: Buffer,
+        network: Network = networks.bitcoin,
+    ): ECPairInterface {
+        return this.ECPair.fromPublicKey(publicKey, { network });
+    }
+
+    /**
+     * Generate a multi-sig address
+     * @param {Buffer[]} pubKeys - The public keys to use
+     * @param {number} minimumSignatureRequired - The minimum number of signatures required
+     * @param {Network} network - The network to use
+     * @returns {Address} - The generated address
+     * @throws {Error} - If the address cannot be generated
+     */
+    public static generateMultiSigAddress(
+        pubKeys: Buffer[],
+        minimumSignatureRequired: number,
+        network: Network = networks.bitcoin,
+    ): Address {
+        const publicKeys: Buffer[] = this.verifyPubKeys(pubKeys, network);
+        const { address } = payments.p2wsh({
+            redeem: payments.p2ms({
+                m: minimumSignatureRequired,
+                pubkeys: publicKeys,
+                network: network,
+            }),
+            network: network,
+        });
+
+        if (!address) {
+            throw new Error('Failed to generate address');
+        }
+
+        return address;
+    }
+
+    /**
+     * Verify public keys and return the public keys
+     * @param {Buffer[]} pubKeys - The public keys to verify
+     * @param {Network} network - The network to use
+     * @returns {Buffer[]} - The verified public keys
+     * @throws {Error} - If the key cannot be regenerated
+     */
+    public static verifyPubKeys(pubKeys: Buffer[], network: Network = networks.bitcoin): Buffer[] {
+        return pubKeys.map((pubKey) => {
+            const key = EcKeyPair.fromPublicKey(pubKey, network);
+
+            if (!key) {
+                throw new Error('Failed to regenerate key');
+            }
+
+            return key.publicKey;
+        });
+    }
+
+    /**
+     * Get a P2WPKH address from a keypair
+     * @param {ECPairInterface} keyPair - The keypair to get the address for
+     * @param {Network} network - The network to use
+     * @returns {Address} - The address
+     */
+    public static getP2WPKHAddress(
+        keyPair: ECPairInterface,
+        network: Network = networks.bitcoin,
+    ): Address {
+        const res = payments.p2wpkh({ pubkey: keyPair.publicKey, network: network });
+
+        if (!res.address) {
+            throw new Error('Failed to generate wallet');
+        }
+
+        return res.address;
+    }
+
+    /**
+     * Generate a random wallet
+     * @param {Network} network - The network to use
+     * @returns {IWallet} - The generated wallet
+     */
+    public static generateWallet(network: Network = networks.bitcoin): IWallet {
+        const keyPair = this.ECPair.makeRandom({
+            network: network,
+        });
+
+        const wallet = this.getP2WPKHAddress(keyPair, network);
+
+        if (!wallet) {
+            throw new Error('Failed to generate wallet');
+        }
+
+        return {
+            address: wallet,
+            privateKey: keyPair.toWIF(),
+            publicKey: keyPair.publicKey.toString('hex'),
+        };
+    }
+
+    /**
+     * Verify that a contract address is a valid p2tr address
+     * @param {Address} contractAddress - The contract address to verify
+     * @param {Network} network - The network to use
+     * @returns {boolean} - Whether the address is valid
+     */
+    public static verifyContractAddress(
+        contractAddress: Address,
+        network: Network = networks.bitcoin,
+    ): boolean {
+        return !!address.toOutputScript(contractAddress, network);
+    }
+
+    /**
+     * Get the legacy address from a keypair
+     * @param {ECPairInterface} keyPair - The keypair to get the address for
+     * @param {Network} network - The network to use
+     * @returns {Address} - The legacy address
+     */
+    public static getLegacyAddress(
+        keyPair: ECPairInterface,
+        network: Network = networks.bitcoin,
+    ): Address {
+        const wallet = payments.p2pkh({ pubkey: keyPair.publicKey, network: network });
+
+        if (!wallet.address) {
+            throw new Error('Failed to generate wallet');
+        }
+
+        return wallet.address;
+    }
+
+    /**
+     * Generate a random keypair
+     * @param {Network} network - The network to use
+     * @returns {ECPairInterface} - The generated keypair
+     */
+    public static generateRandomKeyPair(network: Network = networks.bitcoin): ECPairInterface {
+        return this.ECPair.makeRandom({
+            network: network,
+        });
+    }
+
+    /**
+     * Generate a BIP32 keypair from a seed
+     * @param {Buffer} seed - The seed to generate the keypair from
+     * @param {Network} network - The network to use
+     * @returns {BIP32Interface} - The generated keypair
+     */
+    public static fromSeed(seed: Buffer, network: Network = networks.bitcoin): BIP32Interface {
+        return this.BIP32.fromSeed(seed, network);
+    }
+
+    /**
+     * Get taproot address from keypair
+     * @param {ECPairInterface} keyPair - The keypair to get the taproot address for
+     * @param {Network} network - The network to use
+     * @returns {Address} - The taproot address
+     */
+    public static getTaprootAddress(
+        keyPair: ECPairInterface,
+        network: Network = networks.bitcoin,
+    ): Address {
+        const myXOnlyPubkey = keyPair.publicKey.slice(1, 33);
+
+        const output = Buffer.concat([
+            // witness v1, PUSH_DATA 32 bytes
+            Buffer.from([0x51, 0x20]),
+            // x-only pubkey (remove 1 byte y parity)
+            myXOnlyPubkey,
+        ]);
+
+        return address.fromOutputScript(output, network);
+    }
+
+    /**
+     * Get taproot address from address
+     * @param {Address} inAddr - The address to convert to taproot
+     * @param {Network} network - The network to use
+     * @returns {Address} - The taproot address
+     */
+    public static getTaprootAddressFromAddress(
+        inAddr: Address,
+        network: Network = networks.bitcoin,
+    ): Address {
+        const { address } = payments.p2tr({
+            address: inAddr,
+            network: network,
+        });
+
+        if (!address) {
+            throw new Error(`Failed to generate sender address for transaction`);
+        }
+
+        return address;
+    }
+
+    /**
+     * Get a keypair from a given seed.
+     * @param {Buffer} seed - The seed to generate the key pair from
+     * @param {Network} network - The network to use
+     * @returns {ECPairInterface} - The generated key pair
+     */
+    public static fromSeedKeyPair(
+        seed: Buffer,
+        network: Network = networks.bitcoin,
+    ): ECPairInterface {
+        const fromSeed = this.BIP32.fromSeed(seed, network);
+        const privKey = fromSeed.privateKey;
+        if (!privKey) throw new Error('Failed to generate key pair');
+
+        return this.ECPair.fromPrivateKey(privKey, { network });
+    }
+}

package/src/keypair/Wallet.ts

@@ -0,0 +1,75 @@
+import { IWallet } from './interfaces/IWallet.js';
+import { ECPairInterface } from 'ecpair';
+import { EcKeyPair } from './EcKeyPair.js';
+import { Network, networks } from 'bitcoinjs-lib';
+import { Address } from '@btc-vision/bsi-binary';
+
+/**
+ * Wallet class
+ */
+export class Wallet {
+    /**
+     * Keypair for the wallet
+     * @private
+     */
+    private readonly _keypair: ECPairInterface;
+
+    /**
+     * P2WPKH address for the wallet
+     * @private
+     */
+    private readonly _p2wpkh: Address;
+
+    /**
+     * P2TR address for the wallet
+     * @private
+     */
+    private readonly _p2tr: Address;
+
+    constructor(
+        wallet: IWallet,
+        public readonly network: Network = networks.bitcoin,
+    ) {
+        this._keypair = EcKeyPair.fromWIF(wallet.privateKey, this.network);
+
+        this._p2wpkh = EcKeyPair.getP2WPKHAddress(this._keypair, this.network);
+        this._p2tr = EcKeyPair.getTaprootAddress(this._keypair, this.network);
+    }
+
+    /**
+     * Get the keypair for the wallet
+     * @returns {ECPairInterface}
+     */
+    public get keypair(): ECPairInterface {
+        if (!this._keypair) throw new Error('Keypair not set');
+
+        return this._keypair;
+    }
+
+    /**
+     * Get the P2WPKH address for the wallet
+     * @returns {Address}
+     */
+    public get p2wpkh(): Address {
+        return this._p2wpkh;
+    }
+
+    /**
+     * Get the P2TR address for the wallet
+     * @returns {Address}
+     */
+    public get p2tr(): Address {
+        return this._p2tr;
+    }
+
+    /**
+     * Get the public key for the wallet
+     * @protected
+     * @returns {Buffer}
+     */
+    public get publicKey(): Buffer {
+        if (!this.keypair) throw new Error('Keypair not set');
+
+        return this.keypair.publicKey;
+    }
+}

package/src/keypair/interfaces/IWallet.ts

@@ -0,0 +1,19 @@
+/**
+ * Interface for the generated wallet
+ */
+export interface IWallet {
+    /**
+     * The address of the wallet
+     */
+    readonly address: string;
+
+    /**
+     * The private key of the wallet
+     */
+    readonly privateKey: string;
+
+    /**
+     * The public key of the wallet
+     */
+    readonly publicKey: string;
+}

package/src/metadata/ContractBaseMetadata.ts

@@ -0,0 +1,23 @@
+import { Address } from '@btc-vision/bsi-binary';
+import { Network, networks } from 'bitcoinjs-lib';
+
+export abstract class ContractBaseMetadata {
+    protected abstract readonly address: Address;
+
+    protected constructor(protected network: Network = networks.bitcoin) {}
+
+    /**
+     * @description Get the contract address
+     * @param {Network} network - The network to get the address for
+     */
+    public static getAddress(network: Network = networks.bitcoin): Address {
+        throw new Error('Method not implemented.');
+    }
+
+    /**
+     * @description Get the contract address
+     */
+    public getAddress(): Address {
+        return this.address;
+    }
+}