@btc-vision/transaction 1.0.112 → 1.0.114

package/src/keypair/Address.ts

@@ -0,0 +1,235 @@
+import { Network } from 'bitcoinjs-lib';
+import { EcKeyPair } from './EcKeyPair.js';
+import { ECPairInterface } from 'ecpair';
+import { ADDRESS_BYTE_LENGTH } from '../utils/types.js';
+import { AddressVerificator } from './AddressVerificator.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+
+export class Address extends Uint8Array {
+    private isP2TROnly: boolean = false;
+    #p2tr: string | undefined;
+    #network: Network | undefined;
+
+    public constructor(bytes?: ArrayLike<number>) {
+        super(ADDRESS_BYTE_LENGTH);
+
+        if (!bytes) {
+            return;
+        }
+
+        this.set(bytes);
+    }
+
+    private _keyPair: ECPairInterface | undefined;
+
+    /**
+     * Get the key pair for the address
+     */
+    public get keyPair(): ECPairInterface {
+        if (!this._keyPair) {
+            throw new Error('Public key not set for address');
+        }
+
+        return this._keyPair;
+    }
+
+    public static dead(): Address {
+        return Address.fromString(
+            '0x04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f',
+        );
+    }
+
+    /**
+     * Create an address from a hex string
+     * @param {string} pubKey The public key
+     * @returns {Address} The address
+     */
+    public static fromString(pubKey: string): Address {
+        if (pubKey.startsWith('0x')) {
+            pubKey = pubKey.slice(2);
+        }
+
+        return new Address(Buffer.from(pubKey, 'hex'));
+    }
+
+    /**
+     * Create an address from a public key
+     * @returns {Address} The address
+     * @param {ArrayLike<number>} bytes The public key
+     */
+    public static wrap(bytes: ArrayLike<number>): Address {
+        return new Address(bytes);
+    }
+
+    /**
+     * Converts the address to a hex string
+     * @returns {string} The hex string
+     */
+    public toHex(): string {
+        return '0x' + Buffer.from(this).toString('hex');
+    }
+
+    public equals(a: Address): boolean {
+        if (a.length !== this.length) {
+            return false;
+        }
+
+        for (let i = 0; i < this.length; i++) {
+            if (this[i] !== a[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Check if the address is bigger than another address
+     * @returns {boolean} If bigger
+     */
+    public isBiggerThan(a: Address): boolean {
+        for (let i = 0; i < this.length; i++) {
+            if (this[i] < a[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Check if the address is smaller than another address
+     * @returns {boolean} If smaller
+     */
+    public isSmallerThan(a: Address): boolean {
+        for (let i = 0; i < this.length; i++) {
+            if (this[i] > a[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Set the public key
+     * @param {ArrayLike<number>} publicKey The public key
+     * @returns {void}
+     */
+    public override set(publicKey: ArrayLike<number>): void {
+        if (publicKey.length !== 33 && publicKey.length !== 32 && publicKey.length !== 65) {
+            throw new Error('Invalid public key length');
+        }
+
+        if (publicKey.length === 32) {
+            this.isP2TROnly = true;
+
+            const buf = Buffer.alloc(32);
+            buf.set(publicKey);
+
+            /*let lowByte: number = 0;
+            try {
+                EcKeyPair.tweakPublicKey('02' + buf.toString('hex'));
+                lowByte = 2;
+            } catch (e) {
+                console.log(`Invalid pubkey (2) ${e}`);
+            }
+
+            try {
+                EcKeyPair.tweakPublicKey('03' + buf.toString('hex'));
+                lowByte = 3;
+            } catch (e) {
+                console.log(`Invalid pubkey (3) ${e}`);
+            }
+
+            if (lowByte === 0) {
+                console.log(AddressGenerator.generateTaprootAddress(buf, networks.regtest));
+
+                throw new Error('Invalid public key');
+            }*/
+
+            super.set(publicKey);
+        } else {
+            this._keyPair = EcKeyPair.fromPublicKey(Uint8Array.from(publicKey));
+
+            const tweaked = toXOnly(
+                Buffer.from(
+                    EcKeyPair.tweakPublicKey(this._keyPair.publicKey.toString('hex')),
+                    'hex',
+                ),
+            );
+
+            super.set(Uint8Array.from(tweaked));
+        }
+    }
+
+    /**
+     * Check if the public key is valid
+     * @param {Network} network The network
+     * @returns {boolean} If the public key is valid
+     */
+    public isValid(network: Network): boolean {
+        return AddressVerificator.isValidPublicKey(Buffer.from(this).toString('hex'), network);
+    }
+
+    /**
+     * Get the address in p2wpkh format
+     * @param {Network} network The network
+     */
+    public p2wpkh(network: Network): string {
+        return EcKeyPair.getP2WPKHAddress(this.keyPair, network);
+    }
+
+    /**
+     * Get the address in p2pkh format
+     * @param {Network} network The network
+     */
+    public p2pkh(network: Network): string {
+        return EcKeyPair.getLegacyAddress(this.keyPair, network);
+    }
+
+    /**
+     * Get the address in p2sh-p2wpkh format
+     * @param {Network} network The network
+     */
+    public p2shp2wpkh(network: Network): string {
+        return EcKeyPair.getLegacySegwitAddress(this.keyPair, network);
+    }
+
+    /**
+     * Convert the address to a string
+     */
+    public toString(): string {
+        if (this.#p2tr) {
+            return this.#p2tr;
+        }
+
+        return this.toHex();
+    }
+
+    /**
+     * Get the address in p2tr format
+     * @param {Network} network The network
+     */
+    public p2tr(network: Network): string {
+        if (this.#p2tr && this.#network === network) {
+            return this.#p2tr;
+        }
+
+        let p2trAddy: string | undefined;
+        if (this._keyPair) {
+            p2trAddy = EcKeyPair.getTaprootAddress(this.keyPair, network);
+        } else if (this.isP2TROnly) {
+            p2trAddy = EcKeyPair.tweakedPubKeyBufferToAddress(this, network);
+        }
+
+        if (p2trAddy) {
+            this.#network = network;
+            this.#p2tr = p2trAddy;
+
+            return p2trAddy;
+        }
+
+        throw new Error('Public key not set');
+    }
+}

package/src/keypair/AddressVerificator.ts

@@ -1,11 +1,28 @@
-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: string, network: Network): boolean {
         if (!inAddress || inAddress.length < 50) return false;
 
         let isValidTapRootAddress: boolean = false;
@@ -14,12 +31,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 +57,127 @@ 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 (!hexRegex.test(input)) {
+                return false;
+            }
+
+            if (input.length === 64) {
+                return true;
+            }
+
+            if (input.length === 66 || input.length === 130) {
+                // 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) {
+            // 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
+    }
 }