@btc-vision/transaction 1.0.21 → 1.0.23

package/src/transaction/processor/PsbtTransaction.ts

@@ -0,0 +1,254 @@
+import { Network, payments, Psbt, Signer, Transaction } from 'bitcoinjs-lib';
+import { ITweakedTransactionData, TweakedTransaction } from '../shared/TweakedTransaction.js';
+import { PsbtInputExtended, PsbtOutputExtended } from '../interfaces/Tap.js';
+import { Address } from '@btc-vision/bsi-binary';
+
+export interface PsbtTransactionData extends ITweakedTransactionData {
+    readonly psbt: Psbt;
+    readonly signer: Signer;
+    readonly network: Network;
+    readonly amountRequested: bigint;
+}
+
+export interface IWBTCUTXODocument {
+    readonly vault: Address;
+    readonly blockId: bigint;
+
+    readonly hash: string;
+    readonly value: bigint;
+    readonly outputIndex: number;
+
+    readonly output: string;
+}
+
+export interface VaultUTXOs {
+    readonly vault: Address;
+    readonly publicKeys: Address[];
+    readonly minimum: number;
+    readonly utxos: IWBTCUTXODocument[];
+}
+
+export type FromBase64Params = Omit<PsbtTransactionData, 'psbt'>;
+
+/**
+ * @description PSBT Transaction processor.
+ * */
+export class PsbtTransaction extends TweakedTransaction {
+    public readonly logColor: string = '#00ffe1';
+
+    /**
+     * @description The transaction
+     * @protected
+     */
+    protected readonly transaction: Psbt;
+
+    /**
+     * @description Sign hash types
+     * @protected
+     */
+    protected readonly sighashTypes: number[] = [
+        Transaction.SIGHASH_ALL,
+        Transaction.SIGHASH_ANYONECANPAY,
+    ];
+
+    protected readonly amountRequested: bigint;
+
+    constructor(data: PsbtTransactionData) {
+        super(data);
+
+        if (!data.amountRequested) {
+            throw new Error('Amount requested is required');
+        }
+
+        this.signer = data.signer;
+        this.network = data.network;
+        this.amountRequested = data.amountRequested;
+
+        this.transaction = data.psbt;
+
+        this.tweakSigner();
+        this.internalInit();
+    }
+
+    public static fromBase64(data: string, params: FromBase64Params): PsbtTransaction {
+        const psbt = Psbt.fromBase64(data, {
+            network: params.network,
+        });
+
+        return new PsbtTransaction({
+            ...params,
+            psbt,
+        });
+    }
+
+    /**
+     * @description Add an input to the transaction
+     * @param input
+     */
+    public addInput(input: PsbtInputExtended): void {
+        this.transaction.addInput(input);
+    }
+
+    /**
+     * @description Add an output to the transaction
+     * @param output
+     */
+    public addOutput(output: PsbtOutputExtended): void {
+        this.transaction.addOutput(output);
+    }
+
+    /**
+     * @description Merge vault UTXOs into the transaction
+     * @param {VaultUTXOs[]} input The vault UTXOs
+     * @param {Signer} [firstSigner] The first signer
+     * @public
+     */
+    public mergeVaults(input: VaultUTXOs[], firstSigner?: Signer): void {
+        const firstVault = input[0];
+        if (!firstVault) {
+            throw new Error('No vaults provided');
+        }
+
+        const outputLeftAmount = this.calculateOuputLeftAmountFromVaults(input);
+        if (outputLeftAmount < 0) {
+            throw new Error(
+                `Output left amount is negative ${outputLeftAmount} for vault ${firstVault.vault}`,
+            );
+        }
+
+        this.addOutput({
+            address: firstVault.vault,
+            value: Number(outputLeftAmount),
+        });
+
+        for (const vault of input) {
+            this.addVaultInputs(vault, firstSigner);
+        }
+    }
+
+    /**
+     * Attempt to sign all inputs
+     */
+    public attemptSignAllInputs(): boolean {
+        let signed = false;
+        for (let i = 0; i < this.transaction.data.inputs.length; i++) {
+            const input = this.transaction.data.inputs[i];
+            if (!input.partialSig) {
+                continue;
+            }
+
+            try {
+                this.signInput(this.transaction, input, i, this.signer);
+                signed = true;
+            } catch (e) {}
+        }
+
+        return signed;
+    }
+
+    public attemptFinalizeInputs(): boolean {
+        try {
+            this.transaction.finalizeAllInputs();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * Generate a multi-signature redeem script
+     * @param {string[]} publicKeys The public keys
+     * @param {number} minimum The minimum number of signatures
+     * @protected
+     * @returns {Buffer} The redeem script
+     */
+    protected generateMultiSignRedeemScript(publicKeys: string[], minimum: number): Buffer {
+        const redeemBuffer = payments.p2ms({
+            m: minimum,
+            pubkeys: publicKeys.map((key) => Buffer.from(key, 'base64')),
+            network: this.network,
+        }).output;
+
+        if (!redeemBuffer) {
+            throw new Error('Failed to generate redeem script');
+        }
+
+        return redeemBuffer;
+    }
+
+    /**
+     * @description Calculate the amount left to refund to the first vault.
+     * @param {VaultUTXOs[]} vaults The vaults
+     * @private
+     * @returns {bigint} The amount left
+     */
+    private calculateOuputLeftAmountFromVaults(vaults: VaultUTXOs[]): bigint {
+        let total = BigInt(0);
+        for (const vault of vaults) {
+            for (const utxo of vault.utxos) {
+                total += BigInt(utxo.value);
+            }
+        }
+
+        return total - this.amountRequested;
+    }
+
+    /**
+     * @description Add vault inputs to the transaction
+     * @param {VaultUTXOs} vault The vault UTXOs
+     * @param {Signer} [firstSigner] The first signer
+     * @private
+     */
+    private addVaultInputs(vault: VaultUTXOs, firstSigner: Signer = this.signer): void {
+        const vaultRedeem = this.generateMultiSignRedeemScript(vault.publicKeys, vault.minimum);
+        for (const utxo of vault.utxos) {
+            const inputIndex = this.transaction.inputCount;
+            this.addVaultUTXO(utxo, vaultRedeem);
+
+            if (firstSigner) {
+                this.log(
+                    `Signing input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`,
+                );
+
+                // we don't care if we fail to sign the input
+                try {
+                    this.signInput(
+                        this.transaction,
+                        this.transaction.data.inputs[inputIndex],
+                        inputIndex,
+                        firstSigner,
+                    );
+                } catch (e) {
+                    this.warn(
+                        `Failed to sign input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`,
+                    );
+                }
+            }
+        }
+    }
+
+    /**
+     * @description Add a vault UTXO to the transaction
+     * @param {IWBTCUTXODocument} utxo The UTXO to add
+     * @param {Buffer} redeem The redeem script
+     * @private
+     */
+    private addVaultUTXO(utxo: IWBTCUTXODocument, redeem: Buffer): void {
+        const input: PsbtInputExtended = {
+            hash: Buffer.from(utxo.hash, 'hex'),
+            index: utxo.outputIndex,
+            witnessUtxo: {
+                script: Buffer.from(utxo.output, 'base64'),
+                value: Number(utxo.value),
+            },
+            witnessScript: redeem,
+            partialSig: [],
+        };
+
+        if (this.sighashTypes) {
+            input.sighashType = this.calculateSignHash();
+        }
+
+        this.addInput(input);
+    }
+}

package/src/transaction/psbt/PSBTTypes.ts

@@ -0,0 +1,3 @@
+export enum PSBTTypes {
+    UNWRAP = 0,
+}

package/src/transaction/shared/TweakedTransaction.ts

@@ -0,0 +1,342 @@
+import { Logger } from '@btc-vision/logger';
+import { Network, Payment, payments, Psbt, Signer, Transaction } from 'bitcoinjs-lib';
+import { TweakedSigner, TweakSettings } from '../../signer/TweakedSigner.js';
+import { ECPairInterface } from 'ecpair';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import { PsbtInput } from 'bip174/src/lib/interfaces.js';
+import { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import { PsbtInputExtended, TapLeafScript } from '../interfaces/Tap.js';
+import { AddressVerificator } from '../../keypair/AddressVerificator.js';
+
+export interface ITweakedTransactionData {
+    readonly signer: Signer;
+    readonly network: Network;
+    readonly nonWitnessUtxo?: Buffer;
+}
+
+/**
+ * The transaction sequence
+ */
+export enum TransactionSequence {
+    REPLACE_BY_FEE = 0xfffffffd,
+    FINAL = 0xffffffff,
+}
+
+/**
+ * @description PSBT Transaction processor.
+ * */
+export abstract class TweakedTransaction extends Logger {
+    public readonly logColor: string = '#00ffe1';
+
+    /**
+     * @description Was the transaction signed?
+     */
+    protected signer: Signer;
+
+    /**
+     * @description Tweaked signer
+     */
+    protected tweakedSigner?: Signer;
+
+    /**
+     * @description The network of the transaction
+     */
+    protected network: Network;
+
+    /**
+     * @description Was the transaction signed?
+     */
+    protected signed: boolean = false;
+
+    /**
+     * @description The transaction
+     * @protected
+     */
+    protected abstract readonly transaction: Psbt;
+    /**
+     * @description The sighash types of the transaction
+     * @protected
+     */
+    protected readonly sighashTypes: number[] | undefined;
+
+    /**
+     * @description The script data of the transaction
+     */
+    protected scriptData: Payment | null = null;
+
+    /**
+     * @description The tap data of the transaction
+     */
+    protected tapData: Payment | null = null;
+
+    /**
+     * @description The inputs of the transaction
+     */
+    protected readonly inputs: PsbtInputExtended[] = [];
+
+    /**
+     * @description The sequence of the transaction
+     * @protected
+     */
+    protected sequence: number = TransactionSequence.REPLACE_BY_FEE;
+
+    /**
+     * The tap leaf script
+     * @protected
+     */
+    protected tapLeafScript: TapLeafScript | null = null;
+
+    /**
+     * Add a non-witness utxo to the transaction
+     * @protected
+     */
+    protected nonWitnessUtxo?: Buffer;
+
+    protected constructor(data: ITweakedTransactionData) {
+        super();
+
+        this.signer = data.signer;
+        this.network = data.network;
+
+        this.nonWitnessUtxo = data.nonWitnessUtxo;
+    }
+
+    /**
+     * @description Returns the script address
+     * @returns {string}
+     */
+    public getScriptAddress(): string {
+        if (!this.scriptData || !this.scriptData.address) {
+            throw new Error('Tap data is required');
+        }
+
+        return this.scriptData.address;
+    }
+
+    /**
+     * @description Returns the transaction
+     * @returns {Transaction}
+     */
+    public getTransaction(): Transaction {
+        return this.transaction.extractTransaction(false);
+    }
+
+    /**
+     * @description Returns the tap address
+     * @returns {string}
+     * @throws {Error} - If tap data is not set
+     */
+    public getTapAddress(): string {
+        if (!this.tapData || !this.tapData.address) {
+            throw new Error('Tap data is required');
+        }
+
+        return this.tapData.address;
+    }
+
+    /**
+     * Get the transaction PSBT as a base64 string.
+     * @public
+     * @returns {string} - The transaction as a base64 string
+     */
+    public toBase64(): string {
+        return this.transaction.toBase64();
+    }
+
+    /**
+     * @description Disables replace by fee on the transaction
+     */
+    public disableRBF(): void {
+        if (this.signed) throw new Error('Transaction is already signed');
+
+        this.sequence = TransactionSequence.FINAL;
+
+        for (let input of this.inputs) {
+            input.sequence = TransactionSequence.FINAL;
+        }
+    }
+
+    protected generateTapData(): Payment {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+        };
+    }
+
+    /**
+     * Generates the script address.
+     * @protected
+     * @returns {Payment}
+     */
+    protected generateScriptAddress(): Payment {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+        };
+    }
+
+    /**
+     * Returns the signer key.
+     * @protected
+     * @returns {Signer}
+     */
+    protected getSignerKey(): Signer {
+        return this.signer;
+    }
+
+    /**
+     * Signs an input of the transaction.
+     * @param {Psbt} transaction - The transaction to sign
+     * @param {PsbtInput} input - The input to sign
+     * @param {number} i - The index of the input
+     * @param {Signer} [signer] - The signer to use
+     * @protected
+     */
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer?: Signer): void {
+        const signHash = this.sighashTypes ? [this.calculateSignHash()] : undefined;
+
+        if (input.tapInternalKey) {
+            if (!this.tweakedSigner) throw new Error('Tweaked signer is required');
+            transaction.signTaprootInput(i, this.tweakedSigner, undefined, signHash);
+        } else {
+            transaction.signInput(i, signer || this.getSignerKey(), signHash);
+        }
+    }
+
+    /**
+     * Signs all the inputs of the transaction.
+     * @param {Psbt} transaction - The transaction to sign
+     * @protected
+     * @returns {void}
+     */
+    protected signInputs(transaction: Psbt): void {
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            let input: PsbtInput = transaction.data.inputs[i];
+
+            this.signInput(transaction, input, i);
+        }
+
+        transaction.finalizeAllInputs();
+    }
+
+    /**
+     * Calculate the sign hash number
+     * @description Calculates the sign hash
+     * @protected
+     * @returns {number}
+     */
+    protected calculateSignHash(): number {
+        if (!this.sighashTypes) {
+            throw new Error('Sighash types are required');
+        }
+
+        let signHash: number = 0;
+        for (let sighashType of this.sighashTypes) {
+            signHash |= sighashType;
+        }
+
+        return signHash;
+    }
+
+    /**
+     * Converts the public key to x-only.
+     * @protected
+     * @returns {Buffer}
+     */
+    protected internalPubKeyToXOnly(): Buffer {
+        return toXOnly(this.signer.publicKey);
+    }
+
+    /**
+     * Internal init.
+     * @protected
+     */
+    protected internalInit(): void {
+        this.scriptData = payments.p2tr(this.generateScriptAddress());
+        this.tapData = payments.p2tr(this.generateTapData());
+    }
+
+    /**
+     * Tweak the signer for the interaction
+     * @protected
+     */
+    protected tweakSigner(): void {
+        if (this.tweakedSigner) return;
+
+        // tweaked p2tr signer.
+        this.tweakedSigner = this.getTweakedSigner(true);
+    }
+
+    /**
+     * Get the tweaked signer
+     * @param {boolean} useTweakedHash Whether to use the tweaked hash
+     * @private
+     *
+     * @returns {Signer} The tweaked signer
+     */
+    protected getTweakedSigner(useTweakedHash: boolean = false): Signer {
+        const settings: TweakSettings = {
+            network: this.network,
+        };
+
+        if (useTweakedHash) {
+            settings.tweakHash = this.getTweakerHash();
+        }
+
+        return TweakedSigner.tweakSigner(this.signer as ECPairInterface, settings);
+    }
+
+    /**
+     * Get the tweaked hash
+     * @private
+     *
+     * @returns {Buffer | undefined} The tweaked hash
+     */
+    protected getTweakerHash(): Buffer | undefined {
+        return this.tapData?.hash;
+    }
+
+    /**
+     * Generate the PSBT input extended
+     * @param {UTXO} utxo The UTXO
+     * @param {number} i The index of the input
+     * @protected
+     * @returns {PsbtInputExtended} The PSBT input extended
+     */
+    protected generatePsbtInputExtended(utxo: UTXO, i: number): PsbtInputExtended {
+        const input: PsbtInputExtended = {
+            hash: utxo.transactionId,
+            index: utxo.outputIndex,
+            witnessUtxo: {
+                value: Number(utxo.value),
+                script: Buffer.from(utxo.scriptPubKey.hex, 'hex'),
+            },
+            sequence: this.sequence,
+        };
+
+        if (this.sighashTypes) {
+            input.sighashType = this.calculateSignHash();
+        }
+
+        if (this.tapLeafScript) {
+            input.tapLeafScript = [this.tapLeafScript];
+        }
+
+        if (i === 0 && this.nonWitnessUtxo) {
+            input.nonWitnessUtxo = this.nonWitnessUtxo;
+            this.log(`Using non-witness utxo for input ${i}`);
+        }
+
+        // automatically detect p2tr inputs.
+        if (
+            utxo.scriptPubKey.address &&
+            AddressVerificator.isValidP2TRAddress(utxo.scriptPubKey.address, this.network)
+        ) {
+            this.tweakSigner();
+
+            input.tapInternalKey = this.internalPubKeyToXOnly();
+        }
+
+        return input;
+    }
+}

package/src/utxo/OPNetLimitedProvider.ts

@@ -1,6 +1,7 @@
 import { FetchUTXOParams, FetchUTXOParamsMultiAddress, RawUTXOResponse, UTXO } from './interfaces/IUTXO.js';
 import { WrappedGeneration } from '../wbtc/WrappedGenerationParameters.js';
 import { WrappedGenerationParameters } from '../wbtc/Generate.js';
+import { BroadcastResponse } from './interfaces/BroadcastResponse.js';
 
 /**
  * Allows to fetch UTXO data from any OPNET node
@@ -117,12 +118,32 @@ export class OPNetLimitedProvider {
     }
 
     /**
-     * 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
+     * Broadcasts a transaction to the OPNET node
+     * @param {string} transaction - The transaction to broadcast
+     * @param {boolean} psbt - Whether the transaction is a PSBT
+     * @returns {Promise<BroadcastResponse>} - The response from the OPNET node
      */
-    public async fetchWrapParameters(amount: bigint): Promise<WrappedGeneration | undefined> {
+    public async broadcastTransaction(
+        transaction: string,
+        psbt: boolean,
+    ): Promise<BroadcastResponse | undefined> {
+        const params = [transaction, psbt];
+        const result = await this.rpcMethod('btc_sendRawTransaction', params);
+
+        if (!result) {
+            return;
+        }
+
+        return result as BroadcastResponse;
+    }
+
+    /**
+     * Fetches to the OPNET node
+     * @param {string} method
+     * @param {unknown[]} paramsMethod
+     * @returns {Promise<unknown>}
+     */
+    public async rpcMethod(method: string, paramsMethod: unknown[]): Promise<unknown> {
         const params = {
             method: 'POST',
             headers: {
@@ -130,8 +151,8 @@ export class OPNetLimitedProvider {
             },
             body: JSON.stringify({
                 jsonrpc: '2.0',
-                method: 'btc_generate',
-                params: [0, amount.toString()],
+                method: method,
+                params: paramsMethod,
                 id: 1,
             }),
         };
@@ -146,7 +167,7 @@ export class OPNetLimitedProvider {
 
             const fetchedData = await resp.json();
             if (!fetchedData) {
-                throw new Error('No wrap parameters found');
+                throw new Error('No data fetched');
             }
 
             const result = fetchedData.result;
@@ -158,9 +179,26 @@ export class OPNetLimitedProvider {
                 throw new Error('Something went wrong while fetching wrap parameters');
             }
 
-            return new WrappedGeneration(result as WrappedGenerationParameters);
+            return result;
         } catch (e) {
             console.error(`Failed to fetch wrap parameters: ${(e as Error).stack}`);
         }
     }
+
+    /**
+     * 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 = [0, amount.toString()];
+        const result = await this.rpcMethod('btc_generate', params);
+
+        if (!result) {
+            return;
+        }
+
+        return new WrappedGeneration(result as WrappedGenerationParameters);
+    }
 }

package/src/utxo/interfaces/BroadcastResponse.ts

@@ -0,0 +1,8 @@
+export interface BroadcastResponse {
+    success: boolean;
+    result?: string;
+    error?: string;
+    peers?: number;
+
+    identifier: bigint;
+}