@btc-vision/transaction 1.0.7 → 1.0.9

package/src/transaction/builders/WrapTransaction.ts

@@ -0,0 +1,286 @@
+import { Taptree } from 'bitcoinjs-lib/src/types.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { PsbtOutputExtendedAddress, TapLeafScript } from '../interfaces/Tap.js';
+import { IWrapParameters } from '../interfaces/ITransactionParameters.js';
+import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
+import { wBTC } from '../../metadata/contracts/wBTC.js';
+import { ABICoder, Address, BinaryWriter, Selector } from '@btc-vision/bsi-binary';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { ECPairInterface } from 'ecpair';
+import { WrappedGeneration } from '../../wbtc/WrappedGenerationParameters.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+
+const abiCoder: ABICoder = new ABICoder();
+
+/**
+ * Wrapped Bitcoin transaction wrap interaction
+ * @class InteractionTransaction
+ */
+export class WrapTransaction extends SharedInteractionTransaction<TransactionType.WBTC_WRAP> {
+    private static readonly WRAP_SELECTOR: Selector = Number(
+        '0x' + abiCoder.encodeSelector('mint'),
+    );
+
+    public type: TransactionType.WBTC_WRAP = TransactionType.WBTC_WRAP;
+
+    /**
+     * The vault address
+     * @private
+     * @readonly
+     */
+    public readonly vault: Address;
+
+    /**
+     * The amount to wrap
+     * @private
+     */
+    public readonly amount: bigint;
+
+    /**
+     * The receiver of the wrapped tokens
+     * @private
+     */
+    public readonly receiver: Address;
+
+    /**
+     * The compiled target script
+     * @protected
+     */
+    protected readonly compiledTargetScript: Buffer;
+
+    /**
+     * Tap tree for the interaction
+     * @protected
+     */
+    protected readonly scriptTree: Taptree;
+
+    /**
+     * Tap leaf script
+     * @protected
+     */
+    protected tapLeafScript: TapLeafScript | null = null;
+
+    /**
+     * Contract secret for the interaction
+     * @protected
+     */
+    protected readonly contractSecret: Buffer;
+
+    /**
+     * The wBTC contract
+     * @private
+     */
+    private readonly wbtc: wBTC;
+
+    public constructor(parameters: IWrapParameters) {
+        if (parameters.amount < TransactionBuilder.MINIMUM_DUST) {
+            throw new Error('Amount is below dust limit');
+        }
+
+        const receiver: Address =
+            parameters.receiver ||
+            TransactionBuilder.getFrom(
+                parameters.from,
+                parameters.signer as ECPairInterface,
+                parameters.network,
+            );
+
+        parameters.calldata = WrapTransaction.generateMintCalldata(parameters.amount, receiver);
+
+        super(parameters);
+
+        this.wbtc = new wBTC(parameters.network);
+        this.vault = parameters.generationParameters.vault;
+
+        this.to = this.wbtc.getAddress();
+        this.receiver = receiver;
+        this.amount = parameters.amount;
+
+        this.contractSecret = this.generateSecret();
+
+        if (!this.verifyPublicKeysConstraints(parameters.generationParameters)) {
+            throw new Error(
+                'Oops. Your wrapping request have been decline! It failed security checks!',
+            );
+        }
+
+        this.compiledTargetScript = this.calldataGenerator.compile(
+            this.calldata,
+            this.contractSecret,
+            this.interactionPubKeys,
+            this.minimumSignatures,
+        );
+
+        this.scriptTree = this.getScriptTree();
+        this.internalInit();
+    }
+
+    /**
+     * Generate a valid wBTC calldata
+     * @param {bigint} amount - The amount to wrap
+     * @param {Address} to - The address to send the wrapped tokens to
+     * @private
+     * @returns {Buffer} - The calldata
+     */
+    private static generateMintCalldata(amount: bigint, to: Address): Buffer {
+        if (!amount) throw new Error('Amount is required');
+        if (!to) throw new Error('To address is required');
+
+        const bufWriter: BinaryWriter = new BinaryWriter();
+        bufWriter.writeSelector(WrapTransaction.WRAP_SELECTOR);
+        bufWriter.writeAddress(to);
+        bufWriter.writeU256(amount);
+
+        return Buffer.from(bufWriter.getBuffer());
+    }
+
+    /**
+     * Verify the data integrity received by the client.
+     * @param {WrappedGeneration} generation - The generation parameters
+     * @returns {boolean} - True if the data is valid
+     * @throws {Error} - If the data is invalid
+     */
+    public verifyPublicKeysConstraints(generation: WrappedGeneration): boolean {
+        if (generation.constraints.minimum < 2) {
+            throw new Error('Minimum signatures must be at least 2');
+        }
+
+        if (
+            generation.keys.length < generation.constraints.transactionMinimum ||
+            generation.keys.length < generation.constraints.minimum
+        ) {
+            throw new Error('Not enough pub keys');
+        }
+
+        if (generation.keys.length > 255) {
+            throw new Error('Too many pub keys');
+        }
+
+        const generatedVault: string = this.generateVaultAddress(
+            generation.pubKeys,
+            generation.constraints.minimum,
+        );
+        if (generatedVault !== generation.vault) {
+            throw new Error(
+                `Invalid vault address. Expected: ${generatedVault} Got: ${generation.vault}`,
+            );
+        }
+
+        const passChecksum: Buffer = this.generateChecksumSalt(
+            generation,
+            this.amount,
+            generation.vault,
+        );
+
+        const checksum: string = BitcoinUtils.opnetHash(passChecksum);
+        if (checksum !== generation.signature) {
+            throw new Error(`Invalid checksum. Expected: ${checksum} Got: ${generation.signature}`);
+        }
+
+        return true;
+    }
+
+    /**
+     * Build the transaction
+     * @protected
+     *
+     * @throws {Error} If the leftover funds script redeem is required
+     * @throws {Error} If the leftover funds script redeem version is required
+     * @throws {Error} If the leftover funds script redeem output is required
+     * @throws {Error} If the to address is required
+     */
+    protected override buildTransaction(): void {
+        if (!this.to) throw new Error('To address is required');
+
+        const selectedRedeem = !!this.scriptSigner
+            ? this.targetScriptRedeem
+            : this.leftOverFundsScriptRedeem;
+
+        if (!selectedRedeem) {
+            throw new Error('Left over funds script redeem is required');
+        }
+
+        if (!selectedRedeem.redeemVersion) {
+            throw new Error('Left over funds script redeem version is required');
+        }
+
+        if (!selectedRedeem.output) {
+            throw new Error('Left over funds script redeem output is required');
+        }
+
+        this.tapLeafScript = {
+            leafVersion: selectedRedeem.redeemVersion,
+            script: selectedRedeem.output,
+            controlBlock: this.getWitness(),
+        };
+
+        this.addInputsFromUTXO();
+
+        const amountSpent: bigint = this.getTransactionOPNetFee();
+        this.addOutput({
+            value: Number(amountSpent),
+            address: this.to,
+        });
+
+        this.addVaultOutput();
+        this.addRefundOutput(amountSpent + this.amount);
+    }
+
+    /**
+     * Add the vault output
+     * @private
+     * @throws {Error} If no vault address is provided
+     * @throws {Error} If the amount is not a number
+     */
+    private addVaultOutput(): void {
+        if (!this.vault) {
+            throw new Error(`No vault address provided`);
+        }
+
+        const amountOutput: PsbtOutputExtendedAddress = {
+            address: this.vault,
+            value: Number(this.amount),
+        };
+
+        this.addOutput(amountOutput);
+    }
+
+    /**
+     * Generate a vault address
+     * @param {Buffer[]} keys
+     * @param {number} minimumSignatureRequired
+     * @private
+     * @returns {string}
+     */
+    private generateVaultAddress(keys: Buffer[], minimumSignatureRequired: number): string {
+        return EcKeyPair.generateMultiSigAddress(keys, minimumSignatureRequired, this.network);
+    }
+
+    /**
+     * Generate a wrapped checksum hash
+     * @param {WrappedGeneration} param
+     * @param {bigint} amount
+     * @param {string} vault
+     * @private
+     * @returns {Buffer}
+     */
+    private generateChecksumSalt(param: WrappedGeneration, amount: bigint, vault: string): Buffer {
+        const version: string = param.constraints.version;
+        const timestamp: number = param.constraints.timestamp;
+
+        const params: Buffer = Buffer.alloc(12 + version.length);
+        params.writeBigInt64BE(BigInt(timestamp), 0);
+        params.writeInt16BE(param.constraints.minimum, 8);
+        params.writeInt16BE(param.constraints.transactionMinimum, 10);
+        params.write(version, 12, version.length, 'utf-8');
+
+        return Buffer.concat([
+            ...param.pubKeys,
+            ...param.entities.map((entity: string) => Buffer.from(entity, 'utf-8')),
+            params,
+            Buffer.from(amount.toString(), 'utf-8'),
+            Buffer.from(vault, 'utf-8'),
+        ]);
+    }
+}

package/src/transaction/interfaces/ITransactionParameters.ts

@@ -2,10 +2,11 @@ import { Signer } from 'bitcoinjs-lib';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { Network } from 'bitcoinjs-lib/src/networks.js';
 import { Address } from '@btc-vision/bsi-binary';
+import { WrappedGeneration } from '../../wbtc/WrappedGenerationParameters.js';
 
 export interface ITransactionParameters {
     readonly from?: Address;
-    readonly to: Address;
+    readonly to?: Address | undefined;
     utxos: UTXO[];
 
     readonly signer: Signer;
@@ -15,27 +16,33 @@ export interface ITransactionParameters {
 }
 
 export interface IFundingTransactionParameters extends ITransactionParameters {
-    readonly childTransactionRequiredFees: bigint;
+    childTransactionRequiredValue: bigint;
 }
 
-export interface IInteractionParameters extends ITransactionParameters {
-    readonly calldata: Buffer;
+export interface SharedInteractionParameters extends ITransactionParameters {
+    calldata?: Buffer | undefined;
 
-    readonly pubKeys?: Buffer[];
-    readonly minimumSignatures?: number;
-    
     readonly randomBytes?: Buffer;
 }
 
-export interface ITransactionDataContractInteractionWrap extends IInteractionParameters {
+export interface IInteractionParameters extends SharedInteractionParameters {
+    readonly calldata: Buffer;
+
+    readonly to: Address;
+}
+
+export interface IWrapParameters extends SharedInteractionParameters {
+    readonly to?: undefined;
+
     readonly amount: bigint;
-    readonly minimumSignatures: number;
-    readonly pubKeys: Buffer[];
+    readonly receiver?: Address;
+
+    readonly generationParameters: WrappedGeneration;
 }
 
-export interface ITransactionDataContractDeployment extends ITransactionParameters {
+export interface IDeploymentParameters extends ITransactionParameters {
     readonly bytecode: Buffer;
-    readonly salt: Buffer; // sha256
 
-    readonly customSigner: Signer;
+    readonly to?: undefined;
+    readonly randomBytes?: Buffer;
 }

package/src/utils/BitcoinUtils.ts

@@ -1,3 +1,5 @@
+import { createHash, getRandomValues } from 'crypto';
+
 /**
  * Utility class for Bitcoin related functions
  */
@@ -17,8 +19,22 @@ export class BitcoinUtils {
      * @returns {Buffer} The random bytes
      */
     public static rndBytes(): Buffer {
-        const buf = crypto.getRandomValues(new Uint8Array(64));
+        const buf = getRandomValues(new Uint8Array(64));
 
         return Buffer.from(buf);
     }
+
+    /**
+     * Hashes the given data
+     * @param {Buffer} data - The data to hash
+     * @returns {string} The hashed data
+     */
+    public static opnetHash(data: Buffer): string {
+        const hashed = createHash('sha512');
+        hashed.update(data);
+
+        const hash = hashed.digest();
+
+        return `0x${hash.toString('hex')}`;
+    }
 }

package/src/utxo/{UTXOManager.ts → OPNetLimitedProvider.ts}

@@ -1,10 +1,13 @@
 import { FetchUTXOParams, RawUTXOResponse, UTXO } from './interfaces/IUTXO.js';
+import { WrappedGeneration } from '../wbtc/WrappedGenerationParameters.js';
+import { WrappedGenerationParameters } from '../wbtc/Generate.js';
 
 /**
  * Allows to fetch UTXO data from any OPNET node
  */
-export class UTXOManager {
+export class OPNetLimitedProvider {
     private readonly utxoPath: string = 'address/utxos';
+    private readonly rpc: string = 'json-rpc';
 
     constructor(private readonly opnetAPIUrl: string) {}
 
@@ -57,11 +60,59 @@ export class UTXOManager {
                 scriptPubKey: utxo.scriptPubKey,
             });
 
-            if (currentAmount + utxoValue > amountRequested) {
+            if (currentAmount > amountRequested) {
                 break;
             }
         }
 
         return finalUTXOs;
     }
+
+    /**
+     * Fetches the wrap parameters from the OPNET node
+     * @param {bigint} amount - The amount to wrap
+     * @returns {Promise<WrappedGeneration | undefined>} - The wrap parameters fetched
+     * @throws {Error} - If wrap parameters could not be fetched
+     */
+    public async fetchWrapParameters(amount: bigint): Promise<WrappedGeneration | undefined> {
+        const params = {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'btc_generate',
+                params: [0, amount.toString()],
+                id: 1,
+            }),
+        };
+
+        const url: string = `${this.opnetAPIUrl}/api/v1/${this.rpc}`;
+
+        try {
+            const resp: Response = await fetch(url, params);
+            if (!resp.ok) {
+                throw new Error(`Failed to fetch wrap parameters: ${resp.statusText}`);
+            }
+
+            const fetchedData = await resp.json();
+            if (!fetchedData) {
+                throw new Error('No wrap parameters found');
+            }
+
+            const result = fetchedData.result;
+            if (!result) {
+                throw new Error('No wrap parameters found');
+            }
+
+            if ('error' in result) {
+                throw new Error('Something went wrong while fetching wrap parameters');
+            }
+
+            return new WrappedGeneration(result as WrappedGenerationParameters);
+        } catch (e) {
+            console.error(`Failed to fetch wrap parameters: ${(e as Error).stack}`);
+        }
+    }
 }

package/src/verification/TapscriptVerificator.ts

@@ -1,4 +1,4 @@
-import bitcoin, { Network, networks, Payment, payments } from 'bitcoinjs-lib';
+import { crypto as bitCrypto, Network, networks, Payment, payments } from 'bitcoinjs-lib';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 import { Taptree } from 'bitcoinjs-lib/src/types.js';
 import { DeploymentGenerator } from '../generators/builders/DeploymentGenerator.js';
@@ -50,10 +50,10 @@ export class TapscriptVerificator {
         bytecode: Buffer,
         saltHash: Buffer,
     ): Buffer {
-        const sha256OfBytecode: Buffer = bitcoin.crypto.hash256(bytecode);
+        const sha256OfBytecode: Buffer = bitCrypto.hash256(bytecode);
         const buf: Buffer = Buffer.concat([deployerPubKey, saltHash, sha256OfBytecode]);
 
-        return bitcoin.crypto.hash256(buf);
+        return bitCrypto.hash256(buf);
     }
 
     public static generateContractVirtualAddress(

package/src/wbtc/Generate.ts

@@ -0,0 +1,30 @@
+export interface GenerationConstraints {
+    /** Timestamp of the generation */
+    readonly timestamp: number;
+
+    /** Protocol version used for generation */
+    readonly version: string;
+
+    /** Minimum different trusted validators */
+    readonly minimum: number;
+
+    /** Minimum different trusted validator in a new generated transaction */
+    readonly transactionMinimum: number;
+}
+
+export interface WrappedGenerationParameters {
+    /** Public trusted keys */
+    readonly keys: string[];
+
+    /** Vault address (p2ms) */
+    readonly vault: string;
+
+    /** Public trusted entities */
+    readonly entities: string[];
+
+    /** OPNet Signature that verify the trusted keys and entities */
+    readonly signature: string;
+
+    /** Generation constraints */
+    readonly constraints: GenerationConstraints;
+}

package/src/wbtc/WrappedGenerationParameters.ts

@@ -0,0 +1,33 @@
+import { GenerationConstraints, WrappedGenerationParameters } from './Generate.js';
+
+export class WrappedGeneration implements WrappedGenerationParameters {
+    /** Generation constraints */
+    public readonly constraints: GenerationConstraints;
+
+    /** Public trusted entities */
+    public readonly entities: string[];
+
+    /** Public trusted keys */
+    public readonly keys: string[];
+
+    /** OPNet Signature that verify the trusted keys and entities */
+    public readonly signature: string;
+
+    /** Vault address (p2ms) */
+    public readonly vault: string;
+
+    /**
+     * Public keys of the trusted entities
+     */
+    public readonly pubKeys: Buffer[];
+
+    constructor(params: WrappedGenerationParameters) {
+        this.constraints = params.constraints;
+        this.entities = params.entities;
+        this.keys = params.keys;
+        this.signature = params.signature;
+        this.vault = params.vault;
+
+        this.pubKeys = this.keys.map((key: string) => Buffer.from(key, 'base64'));
+    }
+}

package/tests/TransactionBuilder.test.ts

@@ -1,58 +1,58 @@
-import 'jest';
-import { Regtest } from '../src/tests/Regtest.js';
-import { Logger } from '@btc-vision/logger';
-import { networks } from 'bitcoinjs-lib';
-import {
-    FetchUTXOParams,
-    IInteractionParameters,
-    TransactionFactory,
-    UTXO,
-    UTXOManager,
-    Wallet,
-    wBTC,
-} from '../src/index.js';
-
-const logger: Logger = new Logger();
-const network: networks.Network = networks.regtest;
-
-describe('Transaction Builder', () => {
-    const wBtc: wBTC = new wBTC(network);
-
-    const wallet: Wallet = new Wallet(Regtest.wallet, network);
-    logger.log(`Loaded wallet: ${wallet.p2tr} - ${wallet.p2wpkh}`);
-
-    const utxoManager: UTXOManager = new UTXOManager('http://localhost:9001');
-    const factory: TransactionFactory = new TransactionFactory();
-
-    /** @test {TransactionBuilder#build} */
-    test('should be able to build a transaction', async () => {
-        const utxoSetting: FetchUTXOParams = {
-            address: wallet.p2wpkh,
-            minAmount: 10000n,
-            requestedAmount: 100000n,
-        };
-
-        const utxos: UTXO[] = await utxoManager.fetchUTXO(utxoSetting);
-        console.log(`UTXOs:`, utxos);
-
-        if (!utxos) {
-            throw new Error('No UTXOs found');
-        }
-
-        logger.log(`UTXOs fetched. Count: ${utxos.length}`);
-
-        const interactionParameters: IInteractionParameters = {
-            from: wallet.p2wpkh,
-            to: wBtc.getAddress(),
-            utxos: utxos,
-            signer: wallet.keypair,
-            network: network,
-            feeRate: 150,
-            priorityFee: 500n,
-            calldata: Buffer.from('test'),
-        };
-
-        const finalTx = factory.signInteraction(interactionParameters);
-        console.log(`Transaction:`, finalTx);
-    });
-});
+import 'jest';
+import { Regtest } from '../src/tests/Regtest.js';
+import { Logger } from '@btc-vision/logger';
+import { networks } from 'bitcoinjs-lib';
+import {
+    FetchUTXOParams,
+    IInteractionParameters,
+    OPNetLimitedProvider,
+    TransactionFactory,
+    UTXO,
+    Wallet,
+    wBTC,
+} from '../src/index.js';
+
+const logger: Logger = new Logger();
+const network: networks.Network = networks.regtest;
+
+describe('Transaction Builder', () => {
+    const wBtc: wBTC = new wBTC(network);
+
+    const wallet: Wallet = new Wallet(Regtest.wallet, network);
+    logger.log(`Loaded wallet: ${wallet.p2tr} - ${wallet.p2wpkh}`);
+
+    const utxoManager: OPNetLimitedProvider = new OPNetLimitedProvider('http://localhost:9001');
+    const factory: TransactionFactory = new TransactionFactory();
+
+    /** @test {TransactionBuilder#build} */
+    test('should be able to build a transaction', async () => {
+        const utxoSetting: FetchUTXOParams = {
+            address: wallet.p2wpkh,
+            minAmount: 10000n,
+            requestedAmount: 100000n,
+        };
+
+        const utxos: UTXO[] = await utxoManager.fetchUTXO(utxoSetting);
+        console.log(`UTXOs:`, utxos);
+
+        if (!utxos) {
+            throw new Error('No UTXOs found');
+        }
+
+        logger.log(`UTXOs fetched. Count: ${utxos.length}`);
+
+        const interactionParameters: IInteractionParameters = {
+            from: wallet.p2wpkh,
+            to: wBtc.getAddress(),
+            utxos: utxos,
+            signer: wallet.keypair,
+            network: network,
+            feeRate: 150,
+            priorityFee: 500n,
+            calldata: Buffer.from('test'),
+        };
+
+        const finalTx = factory.signInteraction(interactionParameters);
+        console.log(`Transaction:`, finalTx);
+    });
+});