@btc-vision/transaction 1.0.6 → 1.0.8

package/build/transaction/builders/InteractionTransaction.js

@@ -1,219 +1,16 @@
-import { address } from 'bitcoinjs-lib';
-import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
-import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
-import { Compressor } from '../../bytecode/Compressor.js';
-import { EcKeyPair } from '../../keypair/EcKeyPair.js';
-import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
-import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
-import { TweakedSigner } from '../../signer/TweakedSigner.js';
-export class InteractionTransaction extends TransactionBuilder {
+import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
+export class InteractionTransaction extends SharedInteractionTransaction {
     type = TransactionType.INTERACTION;
-    randomBytes;
-    targetScriptRedeem = null;
-    leftOverFundsScriptRedeem = null;
     compiledTargetScript;
     scriptTree;
     tapLeafScript = null;
-    calldataGenerator;
-    calldata;
-    contractSecret = this.generateSecret();
-    tweakedSigner;
-    scriptSigner;
-    interactionPubKeys;
-    minimumSignatures;
+    contractSecret;
     constructor(parameters) {
         super(parameters);
-        if (!parameters.calldata) {
-            throw new Error('Calldata is required');
-        }
-        this.calldata = Compressor.compress(parameters.calldata);
-        this.interactionPubKeys = parameters.pubKeys || [];
-        this.minimumSignatures = parameters.minimumSignatures || 0;
-        this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
-        this.scriptSigner = this.generateKeyPairFromSeed();
-        this.calldataGenerator = new CalldataGenerator(this.internalPubKeyToXOnly(), this.scriptSignerXOnlyPubKey(), this.network);
+        this.contractSecret = this.generateSecret();
         this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret, this.interactionPubKeys, this.minimumSignatures);
         this.scriptTree = this.getScriptTree();
         this.internalInit();
     }
-    getContractSecret() {
-        return this.contractSecret;
-    }
-    getRndBytes() {
-        return this.randomBytes;
-    }
-    generateSecret() {
-        return address.fromBech32(this.to).data;
-    }
-    tweakSigner() {
-        this.tweakedSigner = this.getTweakedSigner();
-    }
-    scriptSignerXOnlyPubKey() {
-        return toXOnly(this.scriptSigner.publicKey);
-    }
-    generateKeyPairFromSeed() {
-        return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
-    }
-    addInputsFromUTXO() {
-        if (!this.tapLeafScript)
-            throw new Error('Tap leaf script is required');
-        for (let utxo of this.utxos) {
-            const input = {
-                hash: utxo.transactionId,
-                index: utxo.outputIndex,
-                witnessUtxo: {
-                    value: Number(utxo.value),
-                    script: this.getTapOutput(),
-                },
-                tapLeafScript: [this.tapLeafScript],
-                sequence: 0xfffffffd,
-            };
-            this.addInput(input);
-        }
-    }
-    buildTransaction() {
-        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 = this.getTransactionOPNetFee();
-        this.addOutput({
-            value: Number(amountSpent),
-            address: this.to,
-        });
-        this.addRefundOutput(amountSpent);
-    }
-    signInputs(transaction) {
-        if (!this.scriptSigner) {
-            super.signInputs(transaction);
-            return;
-        }
-        transaction.signInput(0, this.scriptSigner);
-        transaction.signInput(0, this.getSignerKey());
-        transaction.finalizeInput(0, this.customFinalizer);
-    }
-    getSignerKey() {
-        if (this.tweakedSigner) {
-            return this.tweakedSigner;
-        }
-        return this.signer;
-    }
-    generateScriptAddress() {
-        return {
-            internalPubkey: this.internalPubKeyToXOnly(),
-            network: this.network,
-            scriptTree: this.scriptTree,
-        };
-    }
-    generateTapData() {
-        const selectedRedeem = !!this.scriptSigner
-            ? this.targetScriptRedeem
-            : this.leftOverFundsScriptRedeem;
-        if (!selectedRedeem) {
-            throw new Error('Left over funds script redeem is required');
-        }
-        if (!this.scriptTree) {
-            throw new Error('Script tree is required');
-        }
-        return {
-            internalPubkey: this.internalPubKeyToXOnly(),
-            network: this.network,
-            scriptTree: this.scriptTree,
-            redeem: selectedRedeem,
-        };
-    }
-    getScriptSolution(input) {
-        if (!input.tapScriptSig) {
-            throw new Error('Tap script signature is required');
-        }
-        return [
-            this.contractSecret,
-            this.internalPubKeyToXOnly(),
-            input.tapScriptSig[0].signature,
-            input.tapScriptSig[1].signature,
-        ];
-    }
-    getPubKeys() {
-        const pubkeys = [this.signer.publicKey];
-        if (this.scriptSigner) {
-            pubkeys.push(this.scriptSigner.publicKey);
-        }
-        return pubkeys;
-    }
-    customFinalizer = (_inputIndex, input) => {
-        if (!this.tapLeafScript) {
-            throw new Error('Tap leaf script is required');
-        }
-        if (!input.tapScriptSig) {
-            throw new Error('Tap script signature is required');
-        }
-        if (!this.contractSecret) {
-            throw new Error('Contract secret is required');
-        }
-        const scriptSolution = this.getScriptSolution(input);
-        const witness = scriptSolution
-            .concat(this.tapLeafScript.script)
-            .concat(this.tapLeafScript.controlBlock);
-        return {
-            finalScriptWitness: this.witnessStackToScriptWitness(witness),
-        };
-    };
-    getTweakerHash() {
-        return this.tapData?.hash;
-    }
-    getTweakedSigner(useTweakedHash = false) {
-        const settings = {
-            network: this.network,
-        };
-        if (useTweakedHash) {
-            settings.tweakHash = this.getTweakerHash();
-        }
-        return TweakedSigner.tweakSigner(this.signer, settings);
-    }
-    generateRedeemScripts() {
-        this.targetScriptRedeem = {
-            pubkeys: this.getPubKeys(),
-            output: this.compiledTargetScript,
-            redeemVersion: 192,
-        };
-        this.leftOverFundsScriptRedeem = {
-            pubkeys: this.getPubKeys(),
-            output: this.getLeafScript(),
-            redeemVersion: 192,
-        };
-    }
-    getLeafScript() {
-        return InteractionTransaction.LOCK_LEAF_SCRIPT;
-    }
-    getScriptTree() {
-        if (!this.calldata) {
-            throw new Error('Calldata is required');
-        }
-        this.generateRedeemScripts();
-        return [
-            {
-                output: this.compiledTargetScript,
-                version: 192,
-            },
-            {
-                output: this.getLeafScript(),
-                version: 192,
-            },
-        ];
-    }
 }

package/build/transaction/builders/SharedInteractionTransaction.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { PsbtInput } from 'bip174/src/lib/interfaces.js';
+import { Payment, Psbt, Signer } from 'bitcoinjs-lib';
+import { Taptree } from 'bitcoinjs-lib/src/types.js';
+import { ECPairInterface } from 'ecpair';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TapLeafScript } from '../interfaces/Tap.js';
+import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
+import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
+export declare abstract class SharedInteractionTransaction<T extends TransactionType> extends TransactionBuilder<T> {
+    readonly randomBytes: Buffer;
+    protected targetScriptRedeem: Payment | null;
+    protected leftOverFundsScriptRedeem: Payment | null;
+    protected abstract readonly compiledTargetScript: Buffer;
+    protected abstract readonly scriptTree: Taptree;
+    protected tapLeafScript: TapLeafScript | null;
+    protected readonly calldataGenerator: CalldataGenerator;
+    protected readonly calldata: Buffer;
+    protected abstract readonly contractSecret: Buffer;
+    protected tweakedSigner?: Signer;
+    protected readonly scriptSigner: Signer;
+    protected readonly interactionPubKeys: Buffer[];
+    protected readonly minimumSignatures: number;
+    protected constructor(parameters: SharedInteractionParameters);
+    getContractSecret(): Buffer;
+    getRndBytes(): Buffer;
+    protected generateSecret(): Buffer;
+    protected tweakSigner(): void;
+    protected scriptSignerXOnlyPubKey(): Buffer;
+    protected generateKeyPairFromSeed(): ECPairInterface;
+    protected addInputsFromUTXO(): void;
+    protected buildTransaction(): void;
+    protected signInputs(transaction: Psbt): void;
+    protected getSignerKey(): Signer;
+    protected generateScriptAddress(): Payment;
+    protected generateTapData(): Payment;
+    protected getScriptSolution(input: PsbtInput): Buffer[];
+    protected getScriptTree(): Taptree;
+    private getPubKeys;
+    private customFinalizer;
+    private getTweakerHash;
+    private getTweakedSigner;
+    private generateRedeemScripts;
+    private getLeafScript;
+}

package/build/transaction/builders/SharedInteractionTransaction.js

@@ -0,0 +1,213 @@
+import { address } from 'bitcoinjs-lib';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
+import { Compressor } from '../../bytecode/Compressor.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import { TweakedSigner } from '../../signer/TweakedSigner.js';
+export class SharedInteractionTransaction extends TransactionBuilder {
+    randomBytes;
+    targetScriptRedeem = null;
+    leftOverFundsScriptRedeem = null;
+    tapLeafScript = null;
+    calldataGenerator;
+    calldata;
+    tweakedSigner;
+    scriptSigner;
+    interactionPubKeys = [];
+    minimumSignatures = 0;
+    constructor(parameters) {
+        super(parameters);
+        if (!parameters.calldata) {
+            throw new Error('Calldata is required');
+        }
+        this.calldata = Compressor.compress(parameters.calldata);
+        this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
+        this.scriptSigner = this.generateKeyPairFromSeed();
+        this.calldataGenerator = new CalldataGenerator(this.internalPubKeyToXOnly(), this.scriptSignerXOnlyPubKey(), this.network);
+    }
+    getContractSecret() {
+        return this.contractSecret;
+    }
+    getRndBytes() {
+        return this.randomBytes;
+    }
+    generateSecret() {
+        if (!this.to)
+            throw new Error('To address is required');
+        return address.fromBech32(this.to).data;
+    }
+    tweakSigner() {
+        this.tweakedSigner = this.getTweakedSigner();
+    }
+    scriptSignerXOnlyPubKey() {
+        return toXOnly(this.scriptSigner.publicKey);
+    }
+    generateKeyPairFromSeed() {
+        return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
+    }
+    addInputsFromUTXO() {
+        if (!this.tapLeafScript)
+            throw new Error('Tap leaf script is required');
+        for (let utxo of this.utxos) {
+            const input = {
+                hash: utxo.transactionId,
+                index: utxo.outputIndex,
+                witnessUtxo: {
+                    value: Number(utxo.value),
+                    script: this.getTapOutput(),
+                },
+                tapLeafScript: [this.tapLeafScript],
+                sequence: this.sequence,
+            };
+            this.addInput(input);
+        }
+    }
+    buildTransaction() {
+        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 = this.getTransactionOPNetFee();
+        this.addOutput({
+            value: Number(amountSpent),
+            address: this.to,
+        });
+        this.addRefundOutput(amountSpent);
+    }
+    signInputs(transaction) {
+        if (!this.scriptSigner) {
+            super.signInputs(transaction);
+            return;
+        }
+        transaction.signInput(0, this.scriptSigner);
+        transaction.signInput(0, this.getSignerKey());
+        transaction.finalizeInput(0, this.customFinalizer);
+    }
+    getSignerKey() {
+        if (this.tweakedSigner) {
+            return this.tweakedSigner;
+        }
+        return this.signer;
+    }
+    generateScriptAddress() {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+            scriptTree: this.scriptTree,
+        };
+    }
+    generateTapData() {
+        const selectedRedeem = !!this.scriptSigner
+            ? this.targetScriptRedeem
+            : this.leftOverFundsScriptRedeem;
+        if (!selectedRedeem) {
+            throw new Error('Left over funds script redeem is required');
+        }
+        if (!this.scriptTree) {
+            throw new Error('Script tree is required');
+        }
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+            scriptTree: this.scriptTree,
+            redeem: selectedRedeem,
+        };
+    }
+    getScriptSolution(input) {
+        if (!input.tapScriptSig) {
+            throw new Error('Tap script signature is required');
+        }
+        return [
+            this.contractSecret,
+            this.internalPubKeyToXOnly(),
+            input.tapScriptSig[0].signature,
+            input.tapScriptSig[1].signature,
+        ];
+    }
+    getScriptTree() {
+        if (!this.calldata) {
+            throw new Error('Calldata is required');
+        }
+        this.generateRedeemScripts();
+        return [
+            {
+                output: this.compiledTargetScript,
+                version: 192,
+            },
+            {
+                output: this.getLeafScript(),
+                version: 192,
+            },
+        ];
+    }
+    getPubKeys() {
+        const pubkeys = [this.signer.publicKey];
+        if (this.scriptSigner) {
+            pubkeys.push(this.scriptSigner.publicKey);
+        }
+        return pubkeys;
+    }
+    customFinalizer = (_inputIndex, input) => {
+        if (!this.tapLeafScript) {
+            throw new Error('Tap leaf script is required');
+        }
+        if (!input.tapScriptSig) {
+            throw new Error('Tap script signature is required');
+        }
+        if (!this.contractSecret) {
+            throw new Error('Contract secret is required');
+        }
+        const scriptSolution = this.getScriptSolution(input);
+        const witness = scriptSolution
+            .concat(this.tapLeafScript.script)
+            .concat(this.tapLeafScript.controlBlock);
+        return {
+            finalScriptWitness: this.witnessStackToScriptWitness(witness),
+        };
+    };
+    getTweakerHash() {
+        return this.tapData?.hash;
+    }
+    getTweakedSigner(useTweakedHash = false) {
+        const settings = {
+            network: this.network,
+        };
+        if (useTweakedHash) {
+            settings.tweakHash = this.getTweakerHash();
+        }
+        return TweakedSigner.tweakSigner(this.signer, settings);
+    }
+    generateRedeemScripts() {
+        this.targetScriptRedeem = {
+            pubkeys: this.getPubKeys(),
+            output: this.compiledTargetScript,
+            redeemVersion: 192,
+        };
+        this.leftOverFundsScriptRedeem = {
+            pubkeys: this.getPubKeys(),
+            output: this.getLeafScript(),
+            redeemVersion: 192,
+        };
+    }
+    getLeafScript() {
+        return SharedInteractionTransaction.LOCK_LEAF_SCRIPT;
+    }
+}

package/build/transaction/builders/TransactionBuilder.d.ts

@@ -5,13 +5,19 @@ import { TransactionType } from '../enums/TransactionType.js';
 import { IFundingTransactionParameters, ITransactionParameters } from '../interfaces/ITransactionParameters.js';
 import { Address } from '@btc-vision/bsi-binary';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import { ECPairInterface } from 'ecpair';
 import { Logger } from '@btc-vision/logger';
+export declare enum TransactionSequence {
+    REPLACE_BY_FEE = 4294967293,
+    FINAL = 4294967295
+}
 export declare abstract class TransactionBuilder<T extends TransactionType> extends Logger {
     static readonly LOCK_LEAF_SCRIPT: Buffer;
     static readonly MINIMUM_DUST: bigint;
     abstract readonly type: T;
     readonly logColor: string;
     transactionFee: bigint;
+    protected sequence: number;
     protected readonly transaction: Psbt;
     protected readonly inputs: PsbtInputExtended[];
     protected readonly updateInputs: UpdateInput[];
@@ -26,10 +32,11 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected readonly feeRate: number;
     protected readonly priorityFee: bigint;
     protected utxos: UTXO[];
-    protected to: Address;
+    protected to: Address | undefined;
     protected from: Address;
     private _maximumFeeRate;
     protected constructor(parameters: ITransactionParameters);
+    static getFrom(from: string | undefined, keypair: ECPairInterface, network: Network): Address;
     getFundingTransactionParameters(): IFundingTransactionParameters;
     setDestinationAddress(address: Address): void;
     setMaximumFeeRate(feeRate: number): void;

package/build/transaction/builders/TransactionBuilder.js

@@ -1,9 +1,14 @@
 import { initEccLib, opcodes, payments, Psbt, script } from 'bitcoinjs-lib';
 import { varuint } from 'bitcoinjs-lib/src/bufferutils.js';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
-import * as ecc from 'tiny-secp256k1';
+import * as ecc from '@bitcoinerlab/secp256k1';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { Logger } from '@btc-vision/logger';
+export var TransactionSequence;
+(function (TransactionSequence) {
+    TransactionSequence[TransactionSequence["REPLACE_BY_FEE"] = 4294967293] = "REPLACE_BY_FEE";
+    TransactionSequence[TransactionSequence["FINAL"] = 4294967295] = "FINAL";
+})(TransactionSequence || (TransactionSequence = {}));
 export class TransactionBuilder extends Logger {
     static LOCK_LEAF_SCRIPT = script.compile([
         opcodes.OP_0,
@@ -11,6 +16,7 @@ export class TransactionBuilder extends Logger {
     static MINIMUM_DUST = 330n;
     logColor = '#785def';
     transactionFee = 0n;
+    sequence = TransactionSequence.REPLACE_BY_FEE;
     transaction;
     inputs = [];
     updateInputs = [];
@@ -35,10 +41,8 @@ export class TransactionBuilder extends Logger {
         this.feeRate = parameters.feeRate;
         this.priorityFee = parameters.priorityFee;
         this.utxos = parameters.utxos;
-        this.to = parameters.to;
-        this.from =
-            parameters.from ||
-                EcKeyPair.getTaprootAddress(this.signer, this.network);
+        this.to = parameters.to || undefined;
+        this.from = TransactionBuilder.getFrom(parameters.from, this.signer, this.network);
         this.totalInputAmount = this.calculateTotalUTXOAmount();
         const totalVOut = this.calculateTotalVOutAmount();
         if (totalVOut < this.totalInputAmount) {
@@ -51,6 +55,9 @@ export class TransactionBuilder extends Logger {
             network: this.network,
         });
     }
+    static getFrom(from, keypair, network) {
+        return from || EcKeyPair.getTaprootAddress(keypair, network);
+    }
     getFundingTransactionParameters() {
         return {
             utxos: this.utxos,
@@ -60,7 +67,7 @@ export class TransactionBuilder extends Logger {
             feeRate: this.feeRate,
             priorityFee: this.priorityFee,
             from: this.from,
-            childTransactionRequiredFees: this.transactionFee,
+            childTransactionRequiredValue: this.transactionFee,
         };
     }
     setDestinationAddress(address) {
@@ -70,10 +77,10 @@ export class TransactionBuilder extends Logger {
         this._maximumFeeRate = feeRate;
     }
     signTransaction() {
-        if (!this.to)
-            throw new Error('Transaction must have a recipient');
-        if (!EcKeyPair.verifyContractAddress(this.to, this.network)) {
-            throw new Error('Invalid contract address. The contract address must be a taproot address.');
+        if (this.to) {
+            if (!EcKeyPair.verifyContractAddress(this.to, this.network)) {
+                throw new Error('Invalid contract address. The contract address must be a taproot address.');
+            }
         }
         if (this.signed)
             throw new Error('Transaction is already signed');
@@ -97,8 +104,9 @@ export class TransactionBuilder extends Logger {
     disableRBF() {
         if (this.signed)
             throw new Error('Transaction is already signed');
+        this.sequence = TransactionSequence.FINAL;
         for (let input of this.inputs) {
-            input.sequence = 0xffffffff;
+            input.sequence = TransactionSequence.FINAL;
         }
     }
     getTapAddress() {
@@ -156,7 +164,7 @@ export class TransactionBuilder extends Logger {
                     value: Number(utxo.value),
                     script: Buffer.from(utxo.scriptPubKey.hex, 'hex'),
                 },
-                sequence: 0xfffffffd,
+                sequence: this.sequence,
             };
             this.addInput(input);
         }

package/build/transaction/builders/WrapTransaction.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { Taptree } from 'bitcoinjs-lib/src/types.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TapLeafScript } from '../interfaces/Tap.js';
+import { IWrapParameters } from '../interfaces/ITransactionParameters.js';
+import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
+import { Address } from '@btc-vision/bsi-binary';
+import { WrappedGeneration } from '../../wbtc/WrappedGenerationParameters.js';
+export declare class WrapTransaction extends SharedInteractionTransaction<TransactionType.WBTC_WRAP> {
+    private static readonly WRAP_SELECTOR;
+    type: TransactionType.WBTC_WRAP;
+    readonly vault: Address;
+    readonly amount: bigint;
+    readonly receiver: Address;
+    protected readonly compiledTargetScript: Buffer;
+    protected readonly scriptTree: Taptree;
+    protected tapLeafScript: TapLeafScript | null;
+    protected readonly contractSecret: Buffer;
+    private readonly wbtc;
+    constructor(parameters: IWrapParameters);
+    private static generateMintCalldata;
+    verifyPublicKeysConstraints(generation: WrappedGeneration): boolean;
+    protected buildTransaction(): void;
+    private addVaultOutput;
+    private generateVaultAddress;
+    private generateChecksumSalt;
+}