@btc-vision/transaction 1.0.113 → 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,6 +1,5 @@
 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);
@@ -23,7 +22,7 @@ export class AddressVerificator {
      * @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 {
+    public static isValidP2TRAddress(inAddress: string, network: Network): boolean {
         if (!inAddress || inAddress.length < 50) return false;
 
         let isValidTapRootAddress: boolean = false;
@@ -104,8 +103,15 @@ export class AddressVerificator {
             // 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 === 66 || input.length === 130) && hexRegex.test(input)) {
+            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);
@@ -113,8 +119,6 @@ export class AddressVerificator {
                 return true;
             }
         } catch (error) {
-            console.log(error);
-
             // If any error occurs (invalid public key, etc.), return false
             return false;
         }

package/src/keypair/EcKeyPair.ts

@@ -1,5 +1,4 @@
 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, Signer } from 'bitcoinjs-lib';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
@@ -73,14 +72,14 @@ export class EcKeyPair {
      * @param {Buffer[]} pubKeys - The public keys to use
      * @param {number} minimumSignatureRequired - The minimum number of signatures required
      * @param {Network} network - The network to use
-     * @returns {Address} - The generated address
+     * @returns {string} - The generated address
      * @throws {Error} - If the address cannot be generated
      */
     public static generateMultiSigAddress(
         pubKeys: Buffer[],
         minimumSignatureRequired: number,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const publicKeys: Buffer[] = this.verifyPubKeys(pubKeys, network);
         if (publicKeys.length !== pubKeys.length) throw new Error(`Contains invalid public keys`);
 
@@ -93,20 +92,6 @@ export class EcKeyPair {
         const p2wsh = payments.p2wsh({ redeem: p2ms, network: network });
         const address = p2wsh.address;
 
-        // fake params
-        /*const multiSignParams: MultiSignParameters = {
-            network: network,
-            utxos: [],
-            pubkeys: pubKeys,
-            minimumSignatures: minimumSignatureRequired,
-            feeRate: 100,
-            receiver: 'a',
-            requestedAmount: 1n,
-            refundVault: 'a',
-        };
-
-        const address = new MultiSignTransaction(multiSignParams).getScriptAddress();
-        */
         if (!address) {
             throw new Error('Failed to generate address');
         }
@@ -137,12 +122,12 @@ export class EcKeyPair {
      * Get a P2WPKH address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The address
+     * @returns {string} - The address
      */
     public static getP2WPKHAddress(
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const res = payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey), network: network });
 
         if (!res.address) {
@@ -156,7 +141,7 @@ export class EcKeyPair {
      * 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
+     * @returns {string} - The address
      * @throws {Error} - If the address cannot be generated
      */
     public static tweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string {
@@ -165,11 +150,28 @@ export class EcKeyPair {
         }
 
         // Convert the tweaked public key hex string to a Buffer
-        const tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        let tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        if (tweakedPubKeyBuffer.length !== 32) tweakedPubKeyBuffer = toXOnly(tweakedPubKeyBuffer);
+
+        return EcKeyPair.tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer, network);
+    }
 
+    /**
+     * Get the address of a tweaked public key
+     * @param {Buffer | Uint8Array} tweakedPubKeyBuffer - The tweaked public key buffer
+     * @param {Network} network - The network to use
+     * @returns {string} - The address
+     * @throws {Error} - If the address cannot be generated
+     */
+    public static tweakedPubKeyBufferToAddress(
+        tweakedPubKeyBuffer: Buffer | Uint8Array,
+        network: Network,
+    ): string {
         // Generate the Taproot address using the p2tr payment method
         const { address } = payments.p2tr({
-            pubkey: toXOnly(tweakedPubKeyBuffer),
+            pubkey: Buffer.isBuffer(tweakedPubKeyBuffer)
+                ? tweakedPubKeyBuffer
+                : Buffer.from(tweakedPubKeyBuffer),
             network: network,
         });
 
@@ -184,7 +186,7 @@ export class EcKeyPair {
      * 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
+     * @returns {string} - The address
      * @throws {Error} - If the address cannot be generated
      */
     public static xOnlyTweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string {
@@ -267,12 +269,12 @@ export class EcKeyPair {
 
     /**
      * Verify that a contract address is a valid p2tr address
-     * @param {Address} contractAddress - The contract address to verify
+     * @param {string} contractAddress - The contract address to verify
      * @param {Network} network - The network to use
      * @returns {boolean} - Whether the address is valid
      */
     public static verifyContractAddress(
-        contractAddress: Address,
+        contractAddress: string,
         network: Network = networks.bitcoin,
     ): boolean {
         return !!address.toOutputScript(contractAddress, network);
@@ -282,12 +284,12 @@ export class EcKeyPair {
      * Get the legacy segwit address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The legacy address
+     * @returns {string} - The legacy address
      */
     public static getLegacySegwitAddress(
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const wallet = payments.p2sh({
             redeem: payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey), network: network }),
             network: network,
@@ -304,12 +306,12 @@ export class EcKeyPair {
      * Get the legacy address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The legacy address
+     * @returns {string} - The legacy address
      */
     public static getLegacyAddress(
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const wallet = payments.p2pkh({ pubkey: Buffer.from(keyPair.publicKey), network: network });
         if (!wallet.address) {
             throw new Error('Failed to generate wallet');
@@ -322,12 +324,12 @@ export class EcKeyPair {
      * Get the legacy address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The legacy address
+     * @returns {string} - The legacy address
      */
     public static getP2PKAddress(
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const wallet = payments.p2pk({ pubkey: Buffer.from(keyPair.publicKey), network: network });
         if (!wallet.output) {
             throw new Error('Failed to generate wallet');
@@ -361,12 +363,12 @@ export class EcKeyPair {
      * Get taproot address from keypair
      * @param {ECPairInterface} keyPair - The keypair to get the taproot address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The taproot address
+     * @returns {string} - The taproot address
      */
     public static getTaprootAddress(
         keyPair: ECPairInterface | Signer,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const { address } = payments.p2tr({
             internalPubkey: toXOnly(Buffer.from(keyPair.publicKey)),
             network: network,
@@ -381,14 +383,14 @@ export class EcKeyPair {
 
     /**
      * Get taproot address from address
-     * @param {Address} inAddr - The address to convert to taproot
+     * @param {string} inAddr - The address to convert to taproot
      * @param {Network} network - The network to use
-     * @returns {Address} - The taproot address
+     * @returns {string} - The taproot address
      */
     public static getTaprootAddressFromAddress(
-        inAddr: Address,
+        inAddr: string,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const { address } = payments.p2tr({
             address: inAddr,
             network: network,

package/src/keypair/Wallet.ts

@@ -2,8 +2,8 @@ import { IWallet } from './interfaces/IWallet.js';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from './EcKeyPair.js';
 import { Network, networks } from 'bitcoinjs-lib';
-import { Address } from '@btc-vision/bsi-binary';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import { Address } from './Address.js';
 
 /**
  * Wallet class
@@ -19,19 +19,25 @@ export class Wallet {
      * P2WPKH address for the wallet
      * @private
      */
-    private readonly _p2wpkh: Address;
+    private readonly _p2wpkh: string;
 
     /**
      * P2TR address for the wallet
      * @private
      */
-    private readonly _p2tr: Address;
+    private readonly _p2tr: string;
 
     /**
      * Legacy address for the wallet
      * @private
      */
-    private readonly _legacy: Address;
+    private readonly _legacy: string;
+
+    /**
+     * Legacy address for the wallet
+     * @private
+     */
+    private readonly _segwitLegacy: string;
 
     /**
      * Buffer public key
@@ -39,6 +45,18 @@ export class Wallet {
      */
     private readonly _bufferPubKey: Buffer;
 
+    /**
+     * Tweaked key
+     * @private
+     */
+    private readonly _tweakedKey: Buffer;
+
+    /**
+     * Address corresponding to the wallet
+     * @private
+     */
+    private readonly _address: Address;
+
     constructor(
         wallet: IWallet,
         public readonly network: Network = networks.bitcoin,
@@ -48,8 +66,31 @@ 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._segwitLegacy = EcKeyPair.getLegacySegwitAddress(this._keypair, this.network);
+
+        this._tweakedKey = Buffer.from(
+            EcKeyPair.tweakPublicKey(this._keypair.publicKey.toString('hex')),
+            'hex',
+        );
 
         this._bufferPubKey = Buffer.from(wallet.publicKey, 'hex');
+        this._address = new Address(this._keypair.publicKey);
+    }
+
+    /**
+     * Get the address for the wallet
+     * @returns {Address}
+     */
+    public get address(): Address {
+        return this._address;
+    }
+
+    /**
+     * Get the tweaked key
+     * @returns {Buffer}
+     */
+    public get tweakedPubKeyKey(): Buffer {
+        return this._tweakedKey;
     }
 
     /**
@@ -64,25 +105,25 @@ export class Wallet {
 
     /**
      * Get the P2WPKH address for the wallet
-     * @returns {Address}
+     * @returns {string}
      */
-    public get p2wpkh(): Address {
+    public get p2wpkh(): string {
         return this._p2wpkh;
     }
 
     /**
      * Get the P2TR address for the wallet
-     * @returns {Address}
+     * @returns {string}
      */
-    public get p2tr(): Address {
+    public get p2tr(): string {
         return this._p2tr;
     }
 
     /**
      * Get the legacy address for the wallet
-     * @returns {Address}
+     * @returns {string}
      */
-    public get legacy(): Address {
+    public get legacy(): string {
         return this._legacy;
     }
 
@@ -90,8 +131,16 @@ export class Wallet {
      * Get the addresses for the wallet
      * @returns {Address[]}
      */
-    public get addresses(): Address[] {
-        return [this.p2wpkh, this.p2tr, this.legacy];
+    public get addresses(): string[] {
+        return [this.p2wpkh, this.p2tr, this.legacy, this.segwitLegacy];
+    }
+
+    /**
+     * Get the segwit legacy address for the wallet
+     * @returns {string}
+     */
+    public get segwitLegacy(): string {
+        return this._segwitLegacy;
     }
 
     /**

package/src/metadata/ContractBaseMetadata.ts

@@ -1,8 +1,7 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Network, networks } from 'bitcoinjs-lib';
 
 export abstract class ContractBaseMetadata {
-    protected abstract readonly address: Address;
+    protected abstract readonly address: string;
 
     protected constructor(protected network: Network = networks.bitcoin) {}
 
@@ -10,14 +9,14 @@ export abstract class ContractBaseMetadata {
      * @description Get the contract address
      * @param {Network} network - The network to get the address for
      */
-    public static getAddress(network: Network = networks.bitcoin): Address {
+    public static getAddress(network: Network = networks.bitcoin): string {
         throw new Error('Method not implemented.');
     }
 
     /**
      * @description Get the contract address
      */
-    public getAddress(): Address {
+    public getAddress(): string {
         return this.address;
     }
 }

package/src/metadata/contracts/wBTC.ts

@@ -1,8 +1,8 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Network, networks } from 'bitcoinjs-lib';
 import { ChainId } from '../../network/ChainId.js';
 import { ContractBaseMetadata } from '../ContractBaseMetadata.js';
 import { WBTC_ADDRESS_FRACTAL, WBTC_ADDRESS_REGTEST, WBTC_ADDRESS_TESTNET } from '../tokens.js';
+import { Address } from '../../keypair/Address.js';
 
 /**
  * @description Wrapped Bitcoin (wBTC) contract metadata.
@@ -23,7 +23,7 @@ export class wBTC extends ContractBaseMetadata {
      */
     public readonly decimals: number = 8;
 
-    protected readonly address: Address;
+    protected readonly address: string;
 
     constructor(
         protected network: Network = networks.bitcoin,
@@ -34,14 +34,14 @@ export class wBTC extends ContractBaseMetadata {
         this.address = wBTC.getAddress(network, chainId);
     }
 
-    public static getAddress(network: Network = networks.bitcoin, chainId?: ChainId): Address {
+    public static getAddress(network: Network = networks.bitcoin, chainId?: ChainId): string {
         switch (network.bech32) {
             case networks.bitcoin.bech32:
-                return this.getWBTCAddressForChain(chainId ?? ChainId.Bitcoin);
+                return this.getWBTCAddressForChain(chainId ?? ChainId.Bitcoin).p2tr(network);
             case networks.regtest.bech32:
-                return WBTC_ADDRESS_REGTEST;
+                return WBTC_ADDRESS_REGTEST.p2tr(network);
             case networks.testnet.bech32:
-                return WBTC_ADDRESS_TESTNET;
+                return WBTC_ADDRESS_TESTNET.p2tr(network);
             default:
                 throw new Error(`Invalid network: ${network.bech32}`);
         }
@@ -49,12 +49,11 @@ export class wBTC extends ContractBaseMetadata {
 
     private static getWBTCAddressForChain(chainId: ChainId): Address {
         switch (chainId) {
-            case ChainId.Bitcoin:
-                return 'unknown';
+            //case ChainId.Bitcoin:
             case ChainId.Fractal:
                 return WBTC_ADDRESS_FRACTAL;
             default:
-                throw new Error(`Invalid chainId: ${chainId}`);
+                throw new Error(`Unsupported chainId: ${chainId}`);
         }
     }
 }