@btc-vision/transaction 1.0.111 → 1.0.113

package/browser/keypair/AddressVerificator.d.ts

@@ -1,6 +1,18 @@
-import { networks } from 'bitcoinjs-lib';
+import { Network } from 'bitcoinjs-lib';
 import { Address } from '@btc-vision/bsi-binary';
+export declare 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 declare class AddressVerificator {
-    static isValidP2TRAddress(inAddress: Address, network: networks.Network): boolean;
-    static validatePKHAddress(inAddress: string, network: networks.Network): boolean;
+    static isValidP2TRAddress(inAddress: Address, network: Network): boolean;
+    static isP2WPKHAddress(inAddress: string, network: Network): boolean;
+    static isP2PKHOrP2SH(addy: string, network: Network): boolean;
+    static isValidPublicKey(input: string, network: Network): boolean;
+    static validateBitcoinAddress(addy: string, network: Network): AddressTypes | null;
 }

package/browser/keypair/EcKeyPair.d.ts

@@ -1,23 +1,28 @@
 import { Address } from '@btc-vision/bsi-binary';
 import { BIP32API, BIP32Interface } from 'bip32';
-import { Network } from 'bitcoinjs-lib';
+import { Network, Signer } from 'bitcoinjs-lib';
 import { ECPairAPI, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
 export declare class EcKeyPair {
     static BIP32: BIP32API;
     static ECPair: ECPairAPI;
     static fromWIF(wif: string, network?: Network): ECPairInterface;
-    static fromPrivateKey(privateKey: Buffer, network?: Network): ECPairInterface;
-    static fromPublicKey(publicKey: Buffer, network?: Network): ECPairInterface;
+    static fromPrivateKey(privateKey: Buffer | Uint8Array, network?: Network): ECPairInterface;
+    static fromPublicKey(publicKey: Buffer | Uint8Array, network?: Network): ECPairInterface;
     static generateMultiSigAddress(pubKeys: Buffer[], minimumSignatureRequired: number, network?: Network): Address;
     static verifyPubKeys(pubKeys: Buffer[], network?: Network): Buffer[];
     static getP2WPKHAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static tweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string;
+    static xOnlyTweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string;
+    static tweakPublicKey(compressedPubKeyHex: string): string;
     static generateWallet(network?: Network): IWallet;
     static verifyContractAddress(contractAddress: Address, network?: Network): boolean;
+    static getLegacySegwitAddress(keyPair: ECPairInterface, network?: Network): Address;
     static getLegacyAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static getP2PKAddress(keyPair: ECPairInterface, network?: Network): Address;
     static generateRandomKeyPair(network?: Network): ECPairInterface;
     static fromSeed(seed: Buffer, network?: Network): BIP32Interface;
-    static getTaprootAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static getTaprootAddress(keyPair: ECPairInterface | Signer, network?: Network): Address;
     static getTaprootAddressFromAddress(inAddr: Address, network?: Network): Address;
     static fromSeedKeyPair(seed: Buffer, network?: Network): ECPairInterface;
 }

package/browser/keypair/Wallet.d.ts

@@ -8,6 +8,7 @@ export declare class Wallet {
     private readonly _p2wpkh;
     private readonly _p2tr;
     private readonly _legacy;
+    private readonly _bufferPubKey;
     constructor(wallet: IWallet, network?: Network);
     get keypair(): ECPairInterface;
     get p2wpkh(): Address;

package/browser/signer/TweakedSigner.d.ts

@@ -1,9 +1,9 @@
-import { Network, Signer } from 'bitcoinjs-lib';
+import { Network } from 'bitcoinjs-lib';
 import { ECPairInterface } from 'ecpair';
 export interface TweakSettings {
     readonly network?: Network;
     tweakHash?: Buffer;
 }
 export declare class TweakedSigner {
-    static tweakSigner(signer: ECPairInterface, opts?: TweakSettings): Signer;
+    static tweakSigner(signer: ECPairInterface, opts?: TweakSettings): ECPairInterface;
 }

package/browser/transaction/builders/FundingTransaction.d.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 declare class FundingTransaction extends TransactionBuilder<TransactionType.FUNDING> {
     readonly type: TransactionType.FUNDING;
     protected amount: bigint;
@@ -9,5 +10,5 @@ export declare class FundingTransaction extends TransactionBuilder<TransactionTy
     constructor(parameters: IFundingTransactionParameters);
     protected buildTransaction(): Promise<void>;
     protected splitInputs(amountSpent: bigint): void;
-    protected getSignerKey(): Signer;
+    protected getSignerKey(): Signer | ECPairInterface;
 }

package/browser/transaction/builders/MultiSignTransaction.d.ts

@@ -5,6 +5,7 @@ import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { ITransactionParameters } from '../interfaces/ITransactionParameters.js';
 import { Address } from '@btc-vision/bsi-binary';
+import { ECPairInterface } from 'ecpair';
 export interface MultiSignParameters extends Omit<ITransactionParameters, 'priorityFee' | 'signer'> {
     readonly pubkeys: Buffer[];
     readonly minimumSignatures: number;
@@ -37,7 +38,7 @@ export declare class MultiSignTransaction extends TransactionBuilder<Transaction
     constructor(parameters: MultiSignParameters);
     static fromBase64(params: MultiSignFromBase64Params): MultiSignTransaction;
     static verifyIfSigned(psbt: Psbt, signerPubKey: Buffer): boolean;
-    static signPartial(psbt: Psbt, signer: Signer, originalInputCount: number, minimums: number[]): {
+    static signPartial(psbt: Psbt, signer: Signer | ECPairInterface, originalInputCount: number, minimums: number[]): {
         final: boolean;
         signed: boolean;
     };

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

@@ -16,7 +16,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected calldataGenerator: CalldataGenerator;
     protected readonly calldata: Buffer;
     protected abstract readonly contractSecret: Buffer;
-    protected readonly scriptSigner: Signer;
+    protected readonly scriptSigner: Signer | ECPairInterface;
     protected readonly disableAutoRefund: boolean;
     protected constructor(parameters: SharedInteractionParameters);
     getContractSecret(): Buffer;

package/browser/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;
@@ -28,8 +28,9 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected to: Address | undefined;
     protected from: Address;
     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/browser/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/browser/verification/TapscriptVerificator.d.ts

@@ -1,7 +1,7 @@
 import { Network } from 'bitcoinjs-lib';
 import { Taptree } from 'bitcoinjs-lib/src/types.js';
 export interface ContractAddressVerificationParams {
-    readonly deployerPubKeyXOnly: Buffer;
+    readonly deployerPubKey: Buffer;
     readonly contractSaltPubKey: Buffer;
     readonly originalSalt: Buffer;
     readonly bytecode: Buffer;

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.111";
+export declare const version = "1.0.113";

package/build/_version.js

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

package/build/generators/Generator.d.ts

@@ -3,9 +3,11 @@ export declare abstract class Generator {
     static readonly DATA_CHUNK_SIZE: number;
     static readonly MAGIC: Buffer;
     protected readonly senderPubKey: Buffer;
+    protected readonly xSenderPubKey: Buffer;
     protected readonly contractSaltPubKey?: Buffer;
     protected readonly network: Network;
     protected constructor(senderPubKey: Buffer, contractSaltPubKey?: Buffer, network?: Network);
+    get senderFirstByte(): Buffer;
     abstract compile(...args: unknown[]): Buffer;
     protected splitBufferIntoChunks(buffer: Buffer, chunkSize?: number): Array<Buffer[]>;
 }

package/build/generators/Generator.js

@@ -1,10 +1,15 @@
 import { networks } from 'bitcoinjs-lib';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 export class Generator {
     constructor(senderPubKey, contractSaltPubKey, network = networks.bitcoin) {
         this.network = networks.bitcoin;
         this.senderPubKey = senderPubKey;
         this.contractSaltPubKey = contractSaltPubKey;
         this.network = network;
+        this.xSenderPubKey = toXOnly(senderPubKey);
+    }
+    get senderFirstByte() {
+        return Buffer.from([this.senderPubKey[0], 0, 0, 0]);
     }
     splitBufferIntoChunks(buffer, chunkSize = Generator.DATA_CHUNK_SIZE) {
         const chunks = [];

package/build/generators/builders/CalldataGenerator.js

@@ -32,12 +32,14 @@ export class CalldataGenerator extends Generator {
         if (!dataChunks.length)
             throw new Error('No data chunks found');
         let compiledData = [
-            this.senderPubKey,
+            this.senderFirstByte,
+            opcodes.OP_TOALTSTACK,
+            this.xSenderPubKey,
             opcodes.OP_CHECKSIGVERIFY,
             this.contractSaltPubKey,
             opcodes.OP_CHECKSIGVERIFY,
             opcodes.OP_HASH160,
-            crypto.hash160(this.senderPubKey),
+            crypto.hash160(this.xSenderPubKey),
             opcodes.OP_EQUALVERIFY,
             opcodes.OP_HASH160,
             crypto.hash160(contractSecret),

package/build/generators/builders/DeploymentGenerator.js

@@ -18,13 +18,15 @@ export class DeploymentGenerator extends Generator {
             throw new Error('Contract salt public key not set');
         const dataChunks = this.splitBufferIntoChunks(contractBytecode);
         const calldataChunks = calldata ? this.splitBufferIntoChunks(calldata) : [];
-        return [
-            this.senderPubKey,
+        const compiledData = [
+            this.senderFirstByte,
+            opcodes.OP_TOALTSTACK,
+            this.xSenderPubKey,
             opcodes.OP_CHECKSIGVERIFY,
             this.contractSaltPubKey,
             opcodes.OP_CHECKSIGVERIFY,
             opcodes.OP_HASH160,
-            crypto.hash160(this.senderPubKey),
+            crypto.hash160(this.xSenderPubKey),
             opcodes.OP_EQUALVERIFY,
             opcodes.OP_HASH256,
             crypto.hash256(contractSalt),
@@ -41,6 +43,7 @@ export class DeploymentGenerator extends Generator {
             opcodes.OP_ELSE,
             opcodes.OP_1,
             opcodes.OP_ENDIF,
-        ].flat();
+        ];
+        return compiledData.flat();
     }
 }

package/build/keypair/AddressVerificator.d.ts

@@ -1,6 +1,18 @@
-import { networks } from 'bitcoinjs-lib';
+import { Network } from 'bitcoinjs-lib';
 import { Address } from '@btc-vision/bsi-binary';
+export declare 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 declare class AddressVerificator {
-    static isValidP2TRAddress(inAddress: Address, network: networks.Network): boolean;
-    static validatePKHAddress(inAddress: string, network: networks.Network): boolean;
+    static isValidP2TRAddress(inAddress: Address, network: Network): boolean;
+    static isP2WPKHAddress(inAddress: string, network: Network): boolean;
+    static isP2PKHOrP2SH(addy: string, network: Network): boolean;
+    static isValidPublicKey(input: string, network: Network): boolean;
+    static validateBitcoinAddress(addy: string, network: Network): AddressTypes | null;
 }

package/build/keypair/AddressVerificator.js

@@ -1,6 +1,17 @@
 import { address, initEccLib } from 'bitcoinjs-lib';
 import * as ecc from '@bitcoinerlab/secp256k1';
+import { EcKeyPair } from './EcKeyPair.js';
 initEccLib(ecc);
+export var AddressTypes;
+(function (AddressTypes) {
+    AddressTypes["P2PKH"] = "P2PKH";
+    AddressTypes["P2SH"] = "P2SH";
+    AddressTypes["P2SH_P2WPKH"] = "P2SH-P2WPKH";
+    AddressTypes["P2SH_OR_P2SH_P2WPKH"] = "P2SH_OR_P2SH-P2WPKH";
+    AddressTypes["P2PK"] = "P2PK";
+    AddressTypes["P2TR"] = "P2TR";
+    AddressTypes["P2WPKH"] = "P2WPKH";
+})(AddressTypes || (AddressTypes = {}));
 export class AddressVerificator {
     static isValidP2TRAddress(inAddress, network) {
         if (!inAddress || inAddress.length < 50)
@@ -11,10 +22,10 @@ export class AddressVerificator {
             const decodedAddress = address.fromBech32(inAddress);
             isValidTapRootAddress = decodedAddress.version === 1;
         }
-        catch (e) { }
+        catch { }
         return isValidTapRootAddress;
     }
-    static validatePKHAddress(inAddress, network) {
+    static isP2WPKHAddress(inAddress, network) {
         if (!inAddress || inAddress.length < 20 || inAddress.length > 50)
             return false;
         let isValidSegWitAddress = false;
@@ -24,7 +35,67 @@ export class AddressVerificator {
             isValidSegWitAddress =
                 decodedAddress.version === 0 && decodedAddress.data.length === 20;
         }
-        catch (e) { }
+        catch { }
         return isValidSegWitAddress;
     }
+    static isP2PKHOrP2SH(addy, network) {
+        try {
+            const decodedBase58 = address.fromBase58Check(addy);
+            if (decodedBase58.version === network.pubKeyHash) {
+                return true;
+            }
+            return decodedBase58.version === network.scriptHash;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static isValidPublicKey(input, network) {
+        try {
+            if (input.startsWith('0x')) {
+                input = input.slice(2);
+            }
+            const hexRegex = /^[0-9a-fA-F]+$/;
+            if ((input.length === 66 || input.length === 130) && hexRegex.test(input)) {
+                const pubKeyBuffer = Buffer.from(input, 'hex');
+                EcKeyPair.fromPublicKey(pubKeyBuffer, network);
+                return true;
+            }
+        }
+        catch (error) {
+            console.log(error);
+            return false;
+        }
+        return false;
+    }
+    static validateBitcoinAddress(addy, network) {
+        if (AddressVerificator.isValidPublicKey(addy, network)) {
+            return AddressTypes.P2PK;
+        }
+        try {
+            const decodedBase58 = address.fromBase58Check(addy);
+            if (decodedBase58.version === network.pubKeyHash) {
+                return AddressTypes.P2PKH;
+            }
+            if (decodedBase58.version === network.scriptHash) {
+                return AddressTypes.P2SH_OR_P2SH_P2WPKH;
+            }
+        }
+        catch (error) {
+        }
+        try {
+            const decodedBech32 = address.fromBech32(addy);
+            if (decodedBech32.prefix === network.bech32) {
+                if (decodedBech32.version === 0 && decodedBech32.data.length === 20) {
+                    return AddressTypes.P2WPKH;
+                }
+                if (decodedBech32.version === 1 && decodedBech32.data.length === 32) {
+                    return AddressTypes.P2TR;
+                }
+            }
+        }
+        catch (error) {
+        }
+        return null;
+    }
 }

package/build/keypair/EcKeyPair.d.ts

@@ -1,23 +1,28 @@
 import { Address } from '@btc-vision/bsi-binary';
 import { BIP32API, BIP32Interface } from 'bip32';
-import { Network } from 'bitcoinjs-lib';
+import { Network, Signer } from 'bitcoinjs-lib';
 import { ECPairAPI, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
 export declare class EcKeyPair {
     static BIP32: BIP32API;
     static ECPair: ECPairAPI;
     static fromWIF(wif: string, network?: Network): ECPairInterface;
-    static fromPrivateKey(privateKey: Buffer, network?: Network): ECPairInterface;
-    static fromPublicKey(publicKey: Buffer, network?: Network): ECPairInterface;
+    static fromPrivateKey(privateKey: Buffer | Uint8Array, network?: Network): ECPairInterface;
+    static fromPublicKey(publicKey: Buffer | Uint8Array, network?: Network): ECPairInterface;
     static generateMultiSigAddress(pubKeys: Buffer[], minimumSignatureRequired: number, network?: Network): Address;
     static verifyPubKeys(pubKeys: Buffer[], network?: Network): Buffer[];
     static getP2WPKHAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static tweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string;
+    static xOnlyTweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string;
+    static tweakPublicKey(compressedPubKeyHex: string): string;
     static generateWallet(network?: Network): IWallet;
     static verifyContractAddress(contractAddress: Address, network?: Network): boolean;
+    static getLegacySegwitAddress(keyPair: ECPairInterface, network?: Network): Address;
     static getLegacyAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static getP2PKAddress(keyPair: ECPairInterface, network?: Network): Address;
     static generateRandomKeyPair(network?: Network): ECPairInterface;
     static fromSeed(seed: Buffer, network?: Network): BIP32Interface;
-    static getTaprootAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static getTaprootAddress(keyPair: ECPairInterface | Signer, network?: Network): Address;
     static getTaprootAddressFromAddress(inAddr: Address, network?: Network): Address;
     static fromSeedKeyPair(seed: Buffer, network?: Network): ECPairInterface;
 }

package/build/keypair/EcKeyPair.js

@@ -3,6 +3,8 @@ import bip32, { BIP32Factory } from 'bip32';
 import { address, initEccLib, networks, payments } from 'bitcoinjs-lib';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 import { ECPairFactory } from 'ecpair';
+import { CURVE, Point, utils } from '@noble/secp256k1';
+import { taggedHash } from 'bitcoinjs-lib/src/crypto.js';
 initEccLib(ecc);
 const BIP32factory = typeof bip32 === 'function' ? bip32 : BIP32Factory;
 if (!BIP32factory) {
@@ -13,10 +15,11 @@ export class EcKeyPair {
         return this.ECPair.fromWIF(wif, network);
     }
     static fromPrivateKey(privateKey, network = networks.bitcoin) {
-        return this.ECPair.fromPrivateKey(privateKey, { network });
+        return this.ECPair.fromPrivateKey(!Buffer.isBuffer(privateKey) ? Buffer.from(privateKey) : privateKey, { network });
     }
     static fromPublicKey(publicKey, network = networks.bitcoin) {
-        return this.ECPair.fromPublicKey(publicKey, { network });
+        const buf = !Buffer.isBuffer(publicKey) ? Buffer.from(publicKey) : publicKey;
+        return this.ECPair.fromPublicKey(buf, { network });
     }
     static generateMultiSigAddress(pubKeys, minimumSignatureRequired, network = networks.bitcoin) {
         const publicKeys = this.verifyPubKeys(pubKeys, network);
@@ -40,16 +43,58 @@ export class EcKeyPair {
             if (!key) {
                 throw new Error('Failed to regenerate key');
             }
-            return key.publicKey;
+            return Buffer.from(key.publicKey);
         });
     }
     static getP2WPKHAddress(keyPair, network = networks.bitcoin) {
-        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');
         }
         return res.address;
     }
+    static tweakedPubKeyToAddress(tweakedPubKeyHex, network) {
+        if (tweakedPubKeyHex.startsWith('0x')) {
+            tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
+        }
+        const tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        const { address } = payments.p2tr({
+            pubkey: toXOnly(tweakedPubKeyBuffer),
+            network: network,
+        });
+        if (!address) {
+            throw new Error('Failed to generate Taproot address');
+        }
+        return address;
+    }
+    static xOnlyTweakedPubKeyToAddress(tweakedPubKeyHex, network) {
+        if (tweakedPubKeyHex.startsWith('0x')) {
+            tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
+        }
+        const tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        const { address } = payments.p2tr({
+            pubkey: tweakedPubKeyBuffer,
+            network: network,
+        });
+        if (!address) {
+            throw new Error('Failed to generate Taproot address');
+        }
+        return address;
+    }
+    static tweakPublicKey(compressedPubKeyHex) {
+        if (compressedPubKeyHex.startsWith('0x')) {
+            compressedPubKeyHex = compressedPubKeyHex.slice(2);
+        }
+        let P = Point.fromHex(compressedPubKeyHex);
+        if (!P.hasEvenY()) {
+            P = P.negate();
+        }
+        const x = P.toRawBytes(true).slice(1);
+        const tHash = taggedHash('TapTweak', Buffer.from(x));
+        const t = utils.mod(BigInt('0x' + Buffer.from(tHash).toString('hex')), CURVE.n);
+        const Q = P.add(Point.BASE.multiply(t));
+        return Q.toHex(true);
+    }
     static generateWallet(network = networks.bitcoin) {
         const keyPair = this.ECPair.makeRandom({
             network: network,
@@ -61,19 +106,36 @@ export class EcKeyPair {
         return {
             address: wallet,
             privateKey: keyPair.toWIF(),
-            publicKey: keyPair.publicKey.toString('hex'),
+            publicKey: Buffer.from(keyPair.publicKey).toString('hex'),
         };
     }
     static verifyContractAddress(contractAddress, network = networks.bitcoin) {
         return !!address.toOutputScript(contractAddress, network);
     }
+    static getLegacySegwitAddress(keyPair, network = networks.bitcoin) {
+        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;
+    }
     static getLegacyAddress(keyPair, network = networks.bitcoin) {
-        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');
         }
         return wallet.address;
     }
+    static getP2PKAddress(keyPair, network = networks.bitcoin) {
+        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');
+    }
     static generateRandomKeyPair(network = networks.bitcoin) {
         return this.ECPair.makeRandom({
             network: network,
@@ -84,7 +146,7 @@ export class EcKeyPair {
     }
     static getTaprootAddress(keyPair, network = networks.bitcoin) {
         const { address } = payments.p2tr({
-            internalPubkey: toXOnly(keyPair.publicKey),
+            internalPubkey: toXOnly(Buffer.from(keyPair.publicKey)),
             network: network,
         });
         if (!address) {

package/build/keypair/Wallet.d.ts

@@ -8,6 +8,7 @@ export declare class Wallet {
     private readonly _p2wpkh;
     private readonly _p2tr;
     private readonly _legacy;
+    private readonly _bufferPubKey;
     constructor(wallet: IWallet, network?: Network);
     get keypair(): ECPairInterface;
     get p2wpkh(): Address;

package/build/keypair/Wallet.js

@@ -8,6 +8,7 @@ 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');
     }
     get keypair() {
         if (!this._keypair)
@@ -27,14 +28,14 @@ export class Wallet {
         return [this.p2wpkh, this.p2tr, this.legacy];
     }
     get publicKey() {
-        if (!this.keypair)
-            throw new Error('Keypair not set');
-        return this.keypair.publicKey;
+        if (!this._bufferPubKey)
+            throw new Error('Public key not set');
+        return this._bufferPubKey;
     }
     get xOnly() {
         if (!this.keypair)
             throw new Error('Keypair not set');
-        return toXOnly(this.keypair.publicKey);
+        return toXOnly(this._bufferPubKey);
     }
     static fromWif(wif, network = networks.bitcoin) {
         return new Wallet({ privateKey: wif, address: '', publicKey: '' }, network);

package/build/signer/TweakedSigner.d.ts

@@ -1,9 +1,9 @@
-import { Network, Signer } from 'bitcoinjs-lib';
+import { Network } from 'bitcoinjs-lib';
 import { ECPairInterface } from 'ecpair';
 export interface TweakSettings {
     readonly network?: Network;
     tweakHash?: Buffer;
 }
 export declare class TweakedSigner {
-    static tweakSigner(signer: ECPairInterface, opts?: TweakSettings): Signer;
+    static tweakSigner(signer: ECPairInterface, opts?: TweakSettings): ECPairInterface;
 }

package/build/signer/TweakedSigner.js

@@ -13,7 +13,7 @@ export class TweakedSigner {
         if (signer.publicKey[0] === 3) {
             privateKey = ecc.privateNegate(privateKey);
         }
-        const tweakedPrivateKey = ecc.privateAdd(privateKey, tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash));
+        const tweakedPrivateKey = ecc.privateAdd(privateKey, tapTweakHash(toXOnly(Buffer.from(signer.publicKey)), opts.tweakHash));
         if (!tweakedPrivateKey) {
             throw new Error('Invalid tweaked private key!');
         }