@btc-vision/transaction 1.0.111 → 1.0.113

package/src/keypair/EcKeyPair.ts

@@ -1,10 +1,12 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
 import { Address } from '@btc-vision/bsi-binary';
 import bip32, { BIP32API, BIP32Factory, BIP32Interface } from 'bip32';
-import { address, initEccLib, Network, networks, payments } from 'bitcoinjs-lib';
+import { address, initEccLib, Network, networks, payments, Signer } from 'bitcoinjs-lib';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 import { ECPairAPI, ECPairFactory, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
+import { CURVE, Point, utils } from '@noble/secp256k1';
+import { taggedHash } from 'bitcoinjs-lib/src/crypto.js';
 
 initEccLib(ecc);
 
@@ -42,23 +44,28 @@ export class EcKeyPair {
      * @returns {ECPairInterface} - The generated keypair
      */
     public static fromPrivateKey(
-        privateKey: Buffer,
+        privateKey: Buffer | Uint8Array,
         network: Network = networks.bitcoin,
     ): ECPairInterface {
-        return this.ECPair.fromPrivateKey(privateKey, { network });
+        return this.ECPair.fromPrivateKey(
+            !Buffer.isBuffer(privateKey) ? Buffer.from(privateKey) : privateKey,
+            { network },
+        );
     }
 
     /**
      * Generate a keypair from a public key
-     * @param {Buffer} publicKey - The public key to use
+     * @param {Buffer | Uint8Array} publicKey - The public key to use
      * @param {Network} network - The network to use
      * @returns {ECPairInterface} - The generated keypair
      */
     public static fromPublicKey(
-        publicKey: Buffer,
+        publicKey: Buffer | Uint8Array,
         network: Network = networks.bitcoin,
     ): ECPairInterface {
-        return this.ECPair.fromPublicKey(publicKey, { network });
+        const buf = !Buffer.isBuffer(publicKey) ? Buffer.from(publicKey) : publicKey;
+
+        return this.ECPair.fromPublicKey(buf, { network });
     }
 
     /**
@@ -122,7 +129,7 @@ export class EcKeyPair {
                 throw new Error('Failed to regenerate key');
             }
 
-            return key.publicKey;
+            return Buffer.from(key.publicKey);
         });
     }
 
@@ -136,7 +143,7 @@ export class EcKeyPair {
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
     ): Address {
-        const res = payments.p2wpkh({ pubkey: keyPair.publicKey, network: network });
+        const res = payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey), network: network });
 
         if (!res.address) {
             throw new Error('Failed to generate wallet');
@@ -145,6 +152,96 @@ export class EcKeyPair {
         return res.address;
     }
 
+    /**
+     * Get the address of a tweaked public key
+     * @param {string} tweakedPubKeyHex - The tweaked public key hex string
+     * @param {Network} network - The network to use
+     * @returns {Address} - The address
+     * @throws {Error} - If the address cannot be generated
+     */
+    public static tweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string {
+        if (tweakedPubKeyHex.startsWith('0x')) {
+            tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
+        }
+
+        // Convert the tweaked public key hex string to a Buffer
+        const tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+
+        // Generate the Taproot address using the p2tr payment method
+        const { address } = payments.p2tr({
+            pubkey: toXOnly(tweakedPubKeyBuffer),
+            network: network,
+        });
+
+        if (!address) {
+            throw new Error('Failed to generate Taproot address');
+        }
+
+        return address;
+    }
+
+    /**
+     * Get the address of a xOnly tweaked public key
+     * @param {string} tweakedPubKeyHex - The xOnly tweaked public key hex string
+     * @param {Network} network - The network to use
+     * @returns {Address} - The address
+     * @throws {Error} - If the address cannot be generated
+     */
+    public static xOnlyTweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string {
+        if (tweakedPubKeyHex.startsWith('0x')) {
+            tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
+        }
+
+        // Convert the tweaked public key hex string to a Buffer
+        const tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+
+        // Generate the Taproot address using the p2tr payment method
+        const { address } = payments.p2tr({
+            pubkey: tweakedPubKeyBuffer,
+            network: network,
+        });
+
+        if (!address) {
+            throw new Error('Failed to generate Taproot address');
+        }
+
+        return address;
+    }
+
+    /**
+     * Tweak a public key
+     * @param {string} compressedPubKeyHex - The compressed public key hex string
+     * @returns {string} - The tweaked public key hex string
+     * @throws {Error} - If the public key cannot be tweaked
+     */
+    public static tweakPublicKey(compressedPubKeyHex: string): string {
+        if (compressedPubKeyHex.startsWith('0x')) {
+            compressedPubKeyHex = compressedPubKeyHex.slice(2);
+        }
+
+        // Convert the compressed public key hex string to a Point on the curve
+        let P = Point.fromHex(compressedPubKeyHex);
+
+        // Ensure the point has an even y-coordinate
+        if (!P.hasEvenY()) {
+            // Negate the point to get an even y-coordinate
+            P = P.negate();
+        }
+
+        // Get the x-coordinate (32 bytes) of the point
+        const x = P.toRawBytes(true).slice(1); // Remove the prefix byte
+
+        // Compute the tweak t = H_tapTweak(x)
+        const tHash = taggedHash('TapTweak', Buffer.from(x));
+        const t = utils.mod(BigInt('0x' + Buffer.from(tHash).toString('hex')), CURVE.n);
+
+        // Compute Q = P + t*G (where G is the generator point)
+        const Q = P.add(Point.BASE.multiply(t));
+
+        // Return the tweaked public key in compressed form (hex string)
+        return Q.toHex(true);
+    }
+
     /**
      * Generate a random wallet
      * @param {Network} network - The network to use
@@ -164,7 +261,7 @@ export class EcKeyPair {
         return {
             address: wallet,
             privateKey: keyPair.toWIF(),
-            publicKey: keyPair.publicKey.toString('hex'),
+            publicKey: Buffer.from(keyPair.publicKey).toString('hex'),
         };
     }
 
@@ -181,6 +278,28 @@ export class EcKeyPair {
         return !!address.toOutputScript(contractAddress, network);
     }
 
+    /**
+     * Get the legacy segwit 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 getLegacySegwitAddress(
+        keyPair: ECPairInterface,
+        network: Network = networks.bitcoin,
+    ): Address {
+        const wallet = payments.p2sh({
+            redeem: payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey), network: network }),
+            network: network,
+        });
+
+        if (!wallet.address) {
+            throw new Error('Failed to generate wallet');
+        }
+
+        return wallet.address;
+    }
+
     /**
      * Get the legacy address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for
@@ -191,8 +310,7 @@ export class EcKeyPair {
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
     ): Address {
-        const wallet = payments.p2pkh({ pubkey: keyPair.publicKey, network: network });
-
+        const wallet = payments.p2pkh({ pubkey: Buffer.from(keyPair.publicKey), network: network });
         if (!wallet.address) {
             throw new Error('Failed to generate wallet');
         }
@@ -200,6 +318,24 @@ export class EcKeyPair {
         return wallet.address;
     }
 
+    /**
+     * 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 getP2PKAddress(
+        keyPair: ECPairInterface,
+        network: Network = networks.bitcoin,
+    ): Address {
+        const wallet = payments.p2pk({ pubkey: Buffer.from(keyPair.publicKey), network: network });
+        if (!wallet.output) {
+            throw new Error('Failed to generate wallet');
+        }
+
+        return '0x' + wallet.output.toString('hex');
+    }
+
     /**
      * Generate a random keypair
      * @param {Network} network - The network to use
@@ -228,11 +364,11 @@ export class EcKeyPair {
      * @returns {Address} - The taproot address
      */
     public static getTaprootAddress(
-        keyPair: ECPairInterface,
+        keyPair: ECPairInterface | Signer,
         network: Network = networks.bitcoin,
     ): Address {
         const { address } = payments.p2tr({
-            internalPubkey: toXOnly(keyPair.publicKey),
+            internalPubkey: toXOnly(Buffer.from(keyPair.publicKey)),
             network: network,
         });
 

package/src/keypair/Wallet.ts

@@ -33,6 +33,12 @@ export class Wallet {
      */
     private readonly _legacy: Address;
 
+    /**
+     * Buffer public key
+     * @private
+     */
+    private readonly _bufferPubKey: Buffer;
+
     constructor(
         wallet: IWallet,
         public readonly network: Network = networks.bitcoin,
@@ -42,6 +48,8 @@ export class Wallet {
         this._p2wpkh = EcKeyPair.getP2WPKHAddress(this._keypair, this.network);
         this._p2tr = EcKeyPair.getTaprootAddress(this._keypair, this.network);
         this._legacy = EcKeyPair.getLegacyAddress(this._keypair, this.network);
+
+        this._bufferPubKey = Buffer.from(wallet.publicKey, 'hex');
     }
 
     /**
@@ -92,9 +100,9 @@ export class Wallet {
      * @returns {Buffer}
      */
     public get publicKey(): Buffer {
-        if (!this.keypair) throw new Error('Keypair not set');
+        if (!this._bufferPubKey) throw new Error('Public key not set');
 
-        return this.keypair.publicKey;
+        return this._bufferPubKey;
     }
 
     /**
@@ -105,7 +113,7 @@ export class Wallet {
     public get xOnly(): Buffer {
         if (!this.keypair) throw new Error('Keypair not set');
 
-        return toXOnly(this.keypair.publicKey);
+        return toXOnly(this._bufferPubKey);
     }
 
     /**

package/src/signer/TweakedSigner.ts

@@ -31,8 +31,9 @@ export class TweakedSigner {
      * Tweak a signer
      * @param {Signer} signer - The signer to tweak
      * @param {TweakSettings} opts - The tweak settings
+     * @returns {ECPairInterface} - The tweaked signer
      */
-    public static tweakSigner(signer: ECPairInterface, opts: TweakSettings = {}): Signer {
+    public static tweakSigner(signer: ECPairInterface, opts: TweakSettings = {}): ECPairInterface {
         let privateKey: Uint8Array | undefined = signer.privateKey;
         if (!privateKey) {
             throw new Error('Private key is required for tweaking signer!');
@@ -44,7 +45,7 @@ export class TweakedSigner {
 
         const tweakedPrivateKey = ecc.privateAdd(
             privateKey,
-            tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash),
+            tapTweakHash(toXOnly(Buffer.from(signer.publicKey)), opts.tweakHash),
         );
 
         if (!tweakedPrivateKey) {

package/src/transaction/builders/CustomScriptTransaction.ts

@@ -11,6 +11,7 @@ import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { AddressGenerator } from '../../generators/AddressGenerator.js';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 import { PsbtInput } from 'bip174/src/lib/interfaces.js';
+import { ECPairInterface } from 'ecpair';
 
 export interface ICustomTransactionParameters extends SharedInteractionParameters {
     readonly script: (Buffer | Stack)[];
@@ -72,7 +73,7 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      * The contract signer
      * @private
      */
-    private readonly contractSigner: Signer;
+    private readonly contractSigner: Signer | ECPairInterface;
 
     /**
      * The contract salt random bytes
@@ -136,7 +137,7 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      * @protected
      */
     protected contractSignerXOnlyPubKey(): Buffer {
-        return toXOnly(this.contractSigner.publicKey);
+        return toXOnly(Buffer.from(this.contractSigner.publicKey));
     }
 
     /**
@@ -261,7 +262,7 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
         if (!this.tapLeafScript) {
             throw new Error('Tap leaf script is required');
         }
-        
+
         const scriptSolution = this.witnesses;
         const witness = scriptSolution
             .concat(this.tapLeafScript.script)
@@ -277,10 +278,10 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      * @private
      */
     private getPubKeys(): Buffer[] {
-        const pubkeys = [this.signer.publicKey];
+        const pubkeys = [Buffer.from(this.signer.publicKey)];
 
         if (this.contractSigner) {
-            pubkeys.push(this.contractSigner.publicKey);
+            pubkeys.push(Buffer.from(this.contractSigner.publicKey));
         }
 
         return pubkeys;

package/src/transaction/builders/DeploymentTransaction.ts

@@ -13,6 +13,7 @@ import { Compressor } from '../../bytecode/Compressor.js';
 import { AddressGenerator } from '../../generators/AddressGenerator.js';
 import { Address } from '@btc-vision/bsi-binary';
 import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
+import { ECPairInterface } from 'ecpair';
 
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
@@ -75,7 +76,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * The contract signer
      * @private
      */
-    private readonly contractSigner: Signer;
+    private readonly contractSigner: Signer | ECPairInterface;
 
     /**
      * The contract salt random bytes
@@ -100,7 +101,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         this.contractSigner = EcKeyPair.fromSeedKeyPair(this.contractSeed, this.network);
 
         this.deploymentGenerator = new DeploymentGenerator(
-            this.internalPubKeyToXOnly(),
+            Buffer.from(this.signer.publicKey),
             this.contractSignerXOnlyPubKey(),
             this.network,
         );
@@ -145,7 +146,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @protected
      */
     protected contractSignerXOnlyPubKey(): Buffer {
-        return toXOnly(this.contractSigner.publicKey);
+        return toXOnly(Buffer.from(this.contractSigner.publicKey));
     }
 
     /**
@@ -323,10 +324,10 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @private
      */
     private getPubKeys(): Buffer[] {
-        const pubkeys = [this.signer.publicKey];
+        const pubkeys = [Buffer.from(this.signer.publicKey)];
 
         if (this.contractSigner) {
-            pubkeys.push(this.contractSigner.publicKey);
+            pubkeys.push(Buffer.from(this.contractSigner.publicKey));
         }
 
         return pubkeys;

package/src/transaction/builders/FundingTransaction.ts

@@ -2,6 +2,7 @@ import { TransactionType } from '../enums/TransactionType.js';
 import { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
 import { Signer } from 'bitcoinjs-lib';
 import { TransactionBuilder } from './TransactionBuilder.js';
+import { ECPairInterface } from 'ecpair';
 
 export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDING> {
     public readonly type: TransactionType.FUNDING = TransactionType.FUNDING;
@@ -27,6 +28,11 @@ export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDI
 
         if (this.splitInputsInto > 1) {
             this.splitInputs(this.amount);
+        } else if (this.isPubKeyDestination) {
+            this.addOutput({
+                value: Number(this.amount),
+                script: Buffer.from(this.to.slice(2), 'hex'),
+            });
         } else {
             this.addOutput({
                 value: Number(this.amount),
@@ -45,14 +51,21 @@ export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDI
         const splitAmount = amountSpent / BigInt(this.splitInputsInto);
 
         for (let i = 0; i < this.splitInputsInto; i++) {
-            this.addOutput({
-                value: Number(splitAmount),
-                address: this.to,
-            });
+            if (this.isPubKeyDestination) {
+                this.addOutput({
+                    value: Number(splitAmount),
+                    script: Buffer.from(this.to.slice(2), 'hex'),
+                });
+            } else {
+                this.addOutput({
+                    value: Number(splitAmount),
+                    address: this.to,
+                });
+            }
         }
     }
 
-    protected override getSignerKey(): Signer {
+    protected override getSignerKey(): Signer | ECPairInterface {
         return this.signer;
     }
 }

package/src/transaction/builders/MultiSignTransaction.ts

@@ -10,6 +10,7 @@ import { Address } from '@btc-vision/bsi-binary';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { ECPairInterface } from 'ecpair';
 
 export interface MultiSignParameters
     extends Omit<ITransactionParameters, 'priorityFee' | 'signer'> {
@@ -172,7 +173,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
      */
     public static signPartial(
         psbt: Psbt,
-        signer: Signer,
+        signer: Signer | ECPairInterface,
         originalInputCount: number,
         minimums: number[],
     ): {
@@ -498,7 +499,10 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
      * @returns {Promise<boolean>}
      * @throws {Error} - If something went wrong while building the transaction
      */
-    protected override async internalBuildTransaction(transaction: Psbt, checkPartialSigs: boolean = false): Promise<boolean> {
+    protected override async internalBuildTransaction(
+        transaction: Psbt,
+        checkPartialSigs: boolean = false,
+    ): Promise<boolean> {
         const inputs: PsbtInputExtended[] = this.getInputs();
         const outputs: PsbtOutputExtended[] = this.getOutputs();
 

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -50,7 +50,7 @@ export abstract class SharedInteractionTransaction<
      * Script signer for the interaction
      * @protected
      */
-    protected readonly scriptSigner: Signer;
+    protected readonly scriptSigner: Signer | ECPairInterface;
 
     /**
      * Disable auto refund
@@ -73,7 +73,7 @@ export abstract class SharedInteractionTransaction<
         this.scriptSigner = this.generateKeyPairFromSeed();
 
         this.calldataGenerator = new CalldataGenerator(
-            this.internalPubKeyToXOnly(),
+            Buffer.from(this.signer.publicKey),
             this.scriptSignerXOnlyPubKey(),
             this.network,
         );
@@ -113,7 +113,7 @@ export abstract class SharedInteractionTransaction<
      * @returns {Buffer} The internal pubkey as an x-only key
      */
     protected scriptSignerXOnlyPubKey(): Buffer {
-        return toXOnly(this.scriptSigner.publicKey);
+        return toXOnly(Buffer.from(this.scriptSigner.publicKey));
     }
 
     /**
@@ -362,10 +362,10 @@ export abstract class SharedInteractionTransaction<
      * @returns {Buffer[]} The public keys
      */
     private getPubKeys(): Buffer[] {
-        const pubkeys = [this.signer.publicKey];
+        const pubkeys = [Buffer.from(this.signer.publicKey)];
 
         if (this.scriptSigner) {
-            pubkeys.push(this.scriptSigner.publicKey);
+            pubkeys.push(Buffer.from(this.scriptSigner.publicKey));
         }
 
         return pubkeys;

package/src/transaction/builders/TransactionBuilder.ts

@@ -43,70 +43,90 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @description Cost in satoshis of the transaction fee
      */
     public transactionFee: bigint = 0n;
+
     /**
      * @description The estimated fees of the transaction
      */
     public estimatedFees: bigint = 0n;
+
     /**
      * @param {ITransactionParameters} parameters - The transaction parameters
      */
-
     public optionalOutputs: PsbtOutputExtended[] | undefined;
+
     /**
      * @description The transaction itself.
      */
     protected transaction: Psbt;
+
     /**
      * @description Inputs to update later on.
      */
     protected readonly updateInputs: UpdateInput[] = [];
+
     /**
      * @description The outputs of the transaction
      */
     protected readonly outputs: PsbtOutputExtended[] = [];
+
     /**
      * @description Output that will be used to pay the fees
      */
     protected feeOutput: PsbtOutputExtended | null = null;
+
     /**
      * @description The total amount of satoshis in the inputs
      */
     protected totalInputAmount: bigint;
+
     /**
      * @description The signer of the transaction
      */
-    protected readonly signer: Signer;
+    protected readonly signer: Signer | ECPairInterface;
+
     /**
      * @description The network where the transaction will be broadcasted
      */
     protected readonly network: Network;
+
     /**
      * @description The fee rate of the transaction
      */
     protected readonly feeRate: number;
+
     /**
      * @description The opnet priority fee of the transaction
      */
     protected priorityFee: bigint;
+
     /**
      * @description The utxos used in the transaction
      */
     protected utxos: UTXO[];
+
     /**
      * @description The address where the transaction is sent to
      * @protected
      */
     protected to: Address | undefined;
+
     /**
      * @description The address where the transaction is sent from
      * @protected
      */
     protected from: Address;
+
     /**
      * @description The maximum fee rate of the transaction
      */
     protected _maximumFeeRate: number = 100000000;
 
+    /**
+     * @description Is the destionation P2PK
+     * @protected
+     */
+    protected isPubKeyDestination: boolean;
+
     protected constructor(parameters: ITransactionParameters) {
         super(parameters);
 
@@ -121,13 +141,11 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         this.utxos = parameters.utxos;
         this.to = parameters.to || undefined;
 
+        this.isPubKeyDestination = this.to ? this.to.startsWith('0x') : false;
+
         this.optionalOutputs = parameters.optionalOutputs;
 
-        this.from = TransactionBuilder.getFrom(
-            parameters.from,
-            this.signer as ECPairInterface,
-            this.network,
-        );
+        this.from = TransactionBuilder.getFrom(parameters.from, this.signer, this.network);
 
         this.totalInputAmount = this.calculateTotalUTXOAmount();
 
@@ -143,7 +161,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
 
     public static getFrom(
         from: string | undefined,
-        keypair: ECPairInterface,
+        keypair: ECPairInterface | Signer,
         network: Network,
     ): Address {
         return from || EcKeyPair.getTaprootAddress(keypair, network);
@@ -231,7 +249,11 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             throw new Error('No UTXOs specified');
         }
 
-        if (this.to && !EcKeyPair.verifyContractAddress(this.to, this.network)) {
+        if (
+            this.to &&
+            !this.isPubKeyDestination &&
+            !EcKeyPair.verifyContractAddress(this.to, this.network)
+        ) {
             throw new Error(
                 'Invalid contract address. The contract address must be a taproot address.',
             );
@@ -261,7 +283,11 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
     public async generateTransactionMinimalSignatures(
         checkPartialSigs: boolean = false,
     ): Promise<void> {
-        if (this.to && !EcKeyPair.verifyContractAddress(this.to, this.network)) {
+        if (
+            this.to &&
+            !this.isPubKeyDestination &&
+            !EcKeyPair.verifyContractAddress(this.to, this.network)
+        ) {
             throw new Error(
                 'Invalid contract address. The contract address must be a taproot address.',
             );