@btc-vision/transaction 1.0.111 → 1.0.113

package/build/transaction/builders/CustomScriptTransaction.js

@@ -49,7 +49,7 @@ export class CustomScriptTransaction extends TransactionBuilder {
         return this.randomBytes;
     }
     contractSignerXOnlyPubKey() {
-        return toXOnly(this.contractSigner.publicKey);
+        return toXOnly(Buffer.from(this.contractSigner.publicKey));
     }
     async buildTransaction() {
         if (!this.to) {
@@ -125,9 +125,9 @@ export class CustomScriptTransaction extends TransactionBuilder {
         return bitCrypto.hash256(this.randomBytes);
     }
     getPubKeys() {
-        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/build/transaction/builders/DeploymentTransaction.js

@@ -44,7 +44,7 @@ export class DeploymentTransaction extends TransactionBuilder {
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
         this.contractSeed = this.getContractSeed();
         this.contractSigner = EcKeyPair.fromSeedKeyPair(this.contractSeed, this.network);
-        this.deploymentGenerator = new DeploymentGenerator(this.internalPubKeyToXOnly(), this.contractSignerXOnlyPubKey(), this.network);
+        this.deploymentGenerator = new DeploymentGenerator(Buffer.from(this.signer.publicKey), this.contractSignerXOnlyPubKey(), this.network);
         this.compiledTargetScript = this.deploymentGenerator.compile(this.bytecode, this.randomBytes, this.calldata);
         this.scriptTree = this.getScriptTree();
         this.internalInit();
@@ -60,7 +60,7 @@ export class DeploymentTransaction extends TransactionBuilder {
         return this.randomBytes;
     }
     contractSignerXOnlyPubKey() {
-        return toXOnly(this.contractSigner.publicKey);
+        return toXOnly(Buffer.from(this.contractSigner.publicKey));
     }
     async buildTransaction() {
         if (!this.to) {
@@ -156,9 +156,9 @@ export class DeploymentTransaction extends TransactionBuilder {
         return bitCrypto.hash256(buf);
     }
     getPubKeys() {
-        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/build/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/build/transaction/builders/FundingTransaction.js

@@ -16,6 +16,12 @@ export class FundingTransaction extends TransactionBuilder {
         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),
@@ -30,10 +36,18 @@ export class FundingTransaction extends TransactionBuilder {
         }
         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,
+                });
+            }
         }
     }
     getSignerKey() {

package/build/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/build/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/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.internalPubKeyToXOnly(), 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;
@@ -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/build/transaction/builders/TransactionBuilder.js

@@ -25,6 +25,7 @@ export class TransactionBuilder extends TweakedTransaction {
         this.priorityFee = parameters.priorityFee ?? 0n;
         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, this.network);
         this.totalInputAmount = this.calculateTotalUTXOAmount();
@@ -87,7 +88,9 @@ export class TransactionBuilder extends TweakedTransaction {
         if (!this.utxos.length) {
             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.');
         }
         if (this.signed)
@@ -104,7 +107,9 @@ export class TransactionBuilder extends TweakedTransaction {
         throw new Error('Could not sign transaction');
     }
     async generateTransactionMinimalSignatures(checkPartialSigs = false) {
-        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.');
         }
         await this.buildTransaction();

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(toXOnly(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/build/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/verification/TapscriptVerificator.js

@@ -6,7 +6,7 @@ import { AddressGenerator } from '../generators/AddressGenerator.js';
 export class TapscriptVerificator {
     static getContractAddress(params) {
         const network = params.network || networks.bitcoin;
-        const scriptBuilder = new DeploymentGenerator(params.deployerPubKeyXOnly, toXOnly(params.contractSaltPubKey), network);
+        const scriptBuilder = new DeploymentGenerator(params.deployerPubKey, toXOnly(params.contractSaltPubKey), network);
         const compiledTargetScript = scriptBuilder.compile(params.bytecode, params.originalSalt, params.calldata);
         const scriptTree = [
             {
@@ -32,7 +32,7 @@ export class TapscriptVerificator {
     static generateAddressFromScript(params, scriptTree) {
         const network = params.network || networks.bitcoin;
         const transactionData = {
-            internalPubkey: params.deployerPubKeyXOnly,
+            internalPubkey: toXOnly(params.deployerPubKey),
             network: network,
             scriptTree: scriptTree,
         };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.0.111",
+    "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/generators/Generator.ts

@@ -1,4 +1,5 @@
 import { Network, networks } from 'bitcoinjs-lib';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 
 /** Bitcoin Script Generator */
 export abstract class Generator {
@@ -18,6 +19,12 @@ export abstract class Generator {
      */
     protected readonly senderPubKey: Buffer;
 
+    /**
+     * The public key of the sender
+     * @protected
+     */
+    protected readonly xSenderPubKey: Buffer;
+
     /**
      * The public key of the contract salt
      * @protected
@@ -38,6 +45,11 @@ export abstract class Generator {
         this.senderPubKey = senderPubKey;
         this.contractSaltPubKey = contractSaltPubKey;
         this.network = network;
+        this.xSenderPubKey = toXOnly(senderPubKey);
+    }
+
+    public get senderFirstByte(): Buffer {
+        return Buffer.from([this.senderPubKey[0], 0, 0, 0]);
     }
 
     /**

package/src/generators/builders/CalldataGenerator.ts

@@ -75,14 +75,17 @@ 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,
@@ -96,7 +99,7 @@ export class CalldataGenerator extends Generator {
 
             Generator.MAGIC,
         ];
-
+        
         // write pub keys, when requested.
         if (vaultPublicKeys.length > 0) {
             const pubKeyBuffer = CalldataGenerator.getPubKeyAsBuffer(vaultPublicKeys, this.network);

package/src/generators/builders/DeploymentGenerator.ts

@@ -42,15 +42,18 @@ export class DeploymentGenerator extends Generator {
         const dataChunks: Buffer[][] = this.splitBufferIntoChunks(contractBytecode);
         const calldataChunks: Buffer[][] = 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,
@@ -71,6 +74,8 @@ export class DeploymentGenerator extends Generator {
             opcodes.OP_ELSE,
             opcodes.OP_1,
             opcodes.OP_ENDIF,
-        ].flat();
+        ];
+
+        return compiledData.flat();
     }
 }

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
+    }
 }