@btc-vision/transaction 1.0.112 → 1.0.113

package/build/transaction/builders/SharedInteractionTransaction.js

@@ -32,7 +32,7 @@ export class SharedInteractionTransaction extends TransactionBuilder {
         this.calldata = Compressor.compress(parameters.calldata);
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
         this.scriptSigner = this.generateKeyPairFromSeed();
-        this.calldataGenerator = new CalldataGenerator(this.signer.publicKey, this.scriptSignerXOnlyPubKey(), this.network);
+        this.calldataGenerator = new CalldataGenerator(Buffer.from(this.signer.publicKey), this.scriptSignerXOnlyPubKey(), this.network);
     }
     getContractSecret() {
         return this.contractSecret;
@@ -46,7 +46,7 @@ export class SharedInteractionTransaction extends TransactionBuilder {
         return address.fromBech32(this.to).data;
     }
     scriptSignerXOnlyPubKey() {
-        return toXOnly(this.scriptSigner.publicKey);
+        return toXOnly(Buffer.from(this.scriptSigner.publicKey));
     }
     generateKeyPairFromSeed() {
         return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
@@ -188,9 +188,9 @@ export class SharedInteractionTransaction extends TransactionBuilder {
         throw new Error('Failed to sign input');
     }
     getPubKeys() {
-        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/build/transaction/builders/TransactionBuilder.d.ts

@@ -20,7 +20,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected readonly outputs: PsbtOutputExtended[];
     protected feeOutput: PsbtOutputExtended | null;
     protected totalInputAmount: bigint;
-    protected readonly signer: Signer;
+    protected readonly signer: Signer | ECPairInterface;
     protected readonly network: Network;
     protected readonly feeRate: number;
     protected priorityFee: bigint;
@@ -30,7 +30,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected _maximumFeeRate: number;
     protected isPubKeyDestination: boolean;
     protected constructor(parameters: ITransactionParameters);
-    static getFrom(from: string | undefined, keypair: ECPairInterface, network: Network): Address;
+    static getFrom(from: string | undefined, keypair: ECPairInterface | Signer, network: Network): Address;
     static witnessStackToScriptWitness(witness: Buffer[]): Buffer;
     getFundingTransactionParameters(): Promise<IFundingTransactionParameters>;
     setDestinationAddress(address: Address): void;

package/build/transaction/builders/UnwrapTransaction.js

@@ -33,7 +33,7 @@ export class UnwrapTransaction extends SharedInteractionTransaction {
         this.estimatedFeeLoss = UnwrapTransaction.preEstimateTaprootTransactionFees(BigInt(this.feeRate), this.calculateNumInputs(this.vaultUTXOs), 2n, this.calculateNumSignatures(this.vaultUTXOs), 65n, this.calculateNumEmptyWitnesses(this.vaultUTXOs));
         this.amount = parameters.amount;
         this.contractSecret = this.generateSecret();
-        this.calldataGenerator = new CalldataGenerator(this.signer.publicKey, this.scriptSignerXOnlyPubKey(), this.network);
+        this.calldataGenerator = new CalldataGenerator(Buffer.from(this.signer.publicKey), this.scriptSignerXOnlyPubKey(), this.network);
         this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret, [Features.UNWRAP]);
         this.scriptTree = this.getScriptTree();
         this.internalInit();
@@ -173,7 +173,7 @@ export class UnwrapTransaction extends SharedInteractionTransaction {
         }
         return [
             this.contractSecret,
-            toXOnly(this.signer.publicKey),
+            toXOnly(Buffer.from(this.signer.publicKey)),
             input.tapScriptSig[0].signature,
             input.tapScriptSig[1].signature,
         ];

package/build/transaction/shared/TweakedTransaction.d.ts

@@ -1,11 +1,12 @@
 import { Logger } from '@btc-vision/logger';
 import { Network, Payment, Psbt, Signer, Transaction } from 'bitcoinjs-lib';
+import { ECPairInterface } from 'ecpair';
 import { PsbtInput } from 'bip174/src/lib/interfaces.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { PsbtInputExtended, TapLeafScript } from '../interfaces/Tap.js';
 import { ChainId } from '../../network/ChainId.js';
 export interface ITweakedTransactionData {
-    readonly signer: Signer;
+    readonly signer: Signer | ECPairInterface;
     readonly network: Network;
     readonly chainId?: ChainId;
     readonly nonWitnessUtxo?: Buffer;
@@ -17,8 +18,8 @@ export declare enum TransactionSequence {
 export declare abstract class TweakedTransaction extends Logger {
     readonly logColor: string;
     finalized: boolean;
-    protected signer: Signer;
-    protected tweakedSigner?: Signer;
+    protected signer: Signer | ECPairInterface;
+    protected tweakedSigner?: ECPairInterface;
     protected network: Network;
     protected signed: boolean;
     protected abstract readonly transaction: Psbt;
@@ -35,7 +36,7 @@ export declare abstract class TweakedTransaction extends Logger {
     protected constructor(data: ITweakedTransactionData);
     static readScriptWitnessToWitnessStack(Buffer: Buffer): Buffer[];
     static preEstimateTaprootTransactionFees(feeRate: bigint, numInputs: bigint, numOutputs: bigint, numWitnessElements: bigint, witnessElementSize: bigint, emptyWitness: bigint, taprootControlWitnessSize?: bigint, taprootScriptSize?: bigint): bigint;
-    protected static signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer, sighashTypes: number[]): void;
+    protected static signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, sighashTypes: number[]): void;
     protected static calculateSignHash(sighashTypes: number[]): number;
     ignoreSignatureError(): void;
     getScriptAddress(): string;
@@ -46,13 +47,13 @@ export declare abstract class TweakedTransaction extends Logger {
     preEstimateTransactionFees(feeRate: bigint, numInputs: bigint, numOutputs: bigint, numSignatures: bigint, numPubkeys: bigint): bigint;
     protected generateTapData(): Payment;
     protected generateScriptAddress(): Payment;
-    protected getSignerKey(): Signer;
-    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer?: Signer): Promise<void>;
+    protected getSignerKey(): Signer | ECPairInterface;
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer?: Signer | ECPairInterface): Promise<void>;
     protected splitArray<T>(arr: T[], chunkSize: number): T[][];
     protected signInputs(transaction: Psbt): Promise<void>;
     protected internalPubKeyToXOnly(): Buffer;
     protected internalInit(): void;
     protected tweakSigner(): void;
-    protected getTweakedSigner(useTweakedHash?: boolean, signer?: Signer): Signer | undefined;
+    protected getTweakedSigner(useTweakedHash?: boolean, signer?: Signer | ECPairInterface): ECPairInterface | undefined;
     protected generatePsbtInputExtended(utxo: UTXO, i: number): PsbtInputExtended;
 }

package/build/transaction/shared/TweakedTransaction.js

@@ -232,7 +232,7 @@ export class TweakedTransaction extends Logger {
         }
     }
     internalPubKeyToXOnly() {
-        return toXOnly(this.signer.publicKey);
+        return toXOnly(Buffer.from(this.signer.publicKey));
     }
     internalInit() {
         this.scriptData = payments.p2tr(this.generateScriptAddress());

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.0.112",
+    "version": "1.0.113",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -95,6 +95,7 @@
         "@btc-vision/bsi-bitcoin-rpc": "^1.0.29",
         "@btc-vision/logger": "^1.0.6",
         "@eslint/js": "^9.10.0",
+        "@noble/secp256k1": "^1.7.1",
         "assert": "^2.1.0",
         "babel-loader": "^9.1.3",
         "babel-plugin-transform-import-meta": "^2.2.1",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.0.111';
+export const version = '1.0.113';

package/src/keypair/AddressVerificator.ts

@@ -1,11 +1,29 @@
-import { address, initEccLib, networks } from 'bitcoinjs-lib';
+import { address, initEccLib, Network } from 'bitcoinjs-lib';
 import * as ecc from '@bitcoinerlab/secp256k1';
 import { Address } from '@btc-vision/bsi-binary';
+import { EcKeyPair } from './EcKeyPair.js';
 
 initEccLib(ecc);
 
+export enum AddressTypes {
+    P2PKH = 'P2PKH',
+    P2SH = 'P2SH',
+    P2SH_P2WPKH = 'P2SH-P2WPKH',
+    P2SH_OR_P2SH_P2WPKH = 'P2SH_OR_P2SH-P2WPKH',
+    P2PK = 'P2PK',
+    P2TR = 'P2TR',
+    P2WPKH = 'P2WPKH',
+}
+
 export class AddressVerificator {
-    public static isValidP2TRAddress(inAddress: Address, network: networks.Network): boolean {
+    /**
+     * Checks if the given address is a valid P2PKH address.
+     * @param inAddress - The address to check.
+     * @param network - The network to validate against.
+     * @returns - True if the address is a valid P2PKH address, false otherwise.
+     * @remarks This method is useful for validating legacy addresses (P2PKH) without
+     */
+    public static isValidP2TRAddress(inAddress: Address, network: Network): boolean {
         if (!inAddress || inAddress.length < 50) return false;
 
         let isValidTapRootAddress: boolean = false;
@@ -14,12 +32,19 @@ export class AddressVerificator {
 
             const decodedAddress = address.fromBech32(inAddress);
             isValidTapRootAddress = decodedAddress.version === 1;
-        } catch (e) {}
+        } catch {}
 
         return isValidTapRootAddress;
     }
 
-    public static validatePKHAddress(inAddress: string, network: networks.Network): boolean {
+    /**
+     * Checks if the given address is a valid P2PKH address.
+     * @param inAddress - The address to check.
+     * @param network - The network to validate against.
+     * @returns - True if the address is a valid P2PKH address, false otherwise.
+     * @remarks This method is useful for validating legacy addresses (P2PKH) without
+     */
+    public static isP2WPKHAddress(inAddress: string, network: Network): boolean {
         if (!inAddress || inAddress.length < 20 || inAddress.length > 50) return false;
 
         let isValidSegWitAddress: boolean = false;
@@ -33,8 +58,122 @@ export class AddressVerificator {
             // Check if the address is P2WPKH (version 0)
             isValidSegWitAddress =
                 decodedAddress.version === 0 && decodedAddress.data.length === 20;
-        } catch (e) {}
+        } catch {}
 
         return isValidSegWitAddress;
     }
+
+    /**
+     * Checks if the given address is a valid P2PKH or P2SH address.
+     * @param addy - The address to check.
+     * @param network - The network to validate against.
+     * @returns - True if the address is a valid P2PKH or P2SH address, false otherwise.
+     * @remarks This method is useful for validating legacy addresses (P2PKH or P2SH) without
+     */
+    public static isP2PKHOrP2SH(addy: string, network: Network): boolean {
+        try {
+            // First, try to decode as a Base58Check address (P2PKH, P2SH, or P2SH-P2WPKH)
+            const decodedBase58 = address.fromBase58Check(addy);
+
+            if (decodedBase58.version === network.pubKeyHash) {
+                // P2PKH: Legacy address (starting with '1' for mainnet, 'm/n' for testnet)
+                return true;
+            }
+
+            return decodedBase58.version === network.scriptHash;
+        } catch (error) {
+            // If decoding fails or version is not valid, it's not a valid legacy address
+            return false;
+        }
+    }
+
+    /**
+     * Checks if the input is a valid hexadecimal public key (P2PK).
+     * Public keys can be compressed (66 characters) or uncompressed (130 characters).
+     *
+     * @param input - The input string to check.
+     * @param network - The Bitcoin network to validate against (mainnet, testnet, etc.).
+     * @returns - True if the input is a valid public key, false otherwise.
+     */
+    public static isValidPublicKey(input: string, network: Network): boolean {
+        try {
+            if (input.startsWith('0x')) {
+                input = input.slice(2);
+            }
+
+            // Compressed public keys are 66 characters long (0x02 or 0x03 prefix + 32 bytes)
+            // Uncompressed public keys are 130 characters long (0x04 prefix + 64 bytes)
+            const hexRegex = /^[0-9a-fA-F]+$/;
+
+            if ((input.length === 66 || input.length === 130) && hexRegex.test(input)) {
+                // Check if the input can be parsed as a valid public key
+                const pubKeyBuffer = Buffer.from(input, 'hex');
+                EcKeyPair.fromPublicKey(pubKeyBuffer, network);
+
+                return true;
+            }
+        } catch (error) {
+            console.log(error);
+
+            // If any error occurs (invalid public key, etc.), return false
+            return false;
+        }
+
+        return false; // Not a valid public key
+    }
+
+    /**
+     * Validates if a given Bitcoin address is of the specified type and network.
+     * - P2PKH (Legacy address starting with '1' for mainnet or 'm/n' for testnet)
+     * - P2SH (Legacy address starting with '3' for mainnet or '2' for testnet)
+     * - P2SH-P2WPKH (Wrapped SegWit)
+     * - P2PK (Pay to PubKey, technically treated similarly to P2PKH)
+     * - P2WPKH (SegWit address starting with 'bc1q' for mainnet or 'tb1q' for testnet)
+     * - P2TR (Taproot address starting with 'bc1p' for mainnet or 'tb1p' for testnet)
+     *
+     * @param addy - The Bitcoin address to validate.
+     * @param network - The Bitcoin network to validate against (mainnet, testnet, etc.).
+     * @returns - The type of the valid Bitcoin address, or null if invalid.
+     */
+    public static validateBitcoinAddress(addy: string, network: Network): AddressTypes | null {
+        if (AddressVerificator.isValidPublicKey(addy, network)) {
+            return AddressTypes.P2PK;
+        }
+
+        try {
+            // First, try to decode as a Base58Check address (P2PKH, P2SH, or P2SH-P2WPKH)
+            const decodedBase58 = address.fromBase58Check(addy);
+
+            if (decodedBase58.version === network.pubKeyHash) {
+                // P2PKH: Legacy address (starting with '1' for mainnet, 'm/n' for testnet)
+                return AddressTypes.P2PKH;
+            }
+            if (decodedBase58.version === network.scriptHash) {
+                // P2SH: Could be P2SH (general) or P2SH-P2WPKH (wrapped SegWit)
+                return AddressTypes.P2SH_OR_P2SH_P2WPKH;
+            }
+        } catch (error) {
+            // Ignore errors from Base58 decoding, it could be a Bech32 address
+        }
+
+        try {
+            // Try to decode as a Bech32 or Bech32m address (P2WPKH or P2TR)
+            const decodedBech32 = address.fromBech32(addy);
+
+            if (decodedBech32.prefix === network.bech32) {
+                // P2WPKH: SegWit address (starting with 'bc1q' for mainnet, 'tb1q' for testnet)
+                if (decodedBech32.version === 0 && decodedBech32.data.length === 20) {
+                    return AddressTypes.P2WPKH;
+                }
+                // P2TR: Taproot address (starting with 'bc1p' for mainnet, 'tb1p' for testnet)
+                if (decodedBech32.version === 1 && decodedBech32.data.length === 32) {
+                    return AddressTypes.P2TR;
+                }
+            }
+        } catch (error) {
+            // Ignore errors from Bech32/Bech32m decoding
+        }
+
+        return null; // Not a valid or recognized Bitcoin address type
+    }
 }

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'),
         };
     }
 
@@ -192,7 +289,7 @@ export class EcKeyPair {
         network: Network = networks.bitcoin,
     ): Address {
         const wallet = payments.p2sh({
-            redeem: payments.p2wpkh({ pubkey: keyPair.publicKey, network: network }),
+            redeem: payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey), network: network }),
             network: network,
         });
 
@@ -213,7 +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');
         }
@@ -231,7 +328,7 @@ export class EcKeyPair {
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
     ): Address {
-        const wallet = payments.p2pk({ pubkey: keyPair.publicKey, network: network });
+        const wallet = payments.p2pk({ pubkey: Buffer.from(keyPair.publicKey), network: network });
         if (!wallet.output) {
             throw new Error('Failed to generate wallet');
         }
@@ -267,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;