@btc-vision/transaction 1.0.113 → 1.0.114

package/build/deterministic/AddressMap.js

@@ -0,0 +1,46 @@
+import { Map } from './Map.js';
+export class AddressMap extends Map {
+    set(key, value) {
+        const index = this._keys.indexOf(key);
+        if (index == -1) {
+            this._keys.push(key);
+            this._values.push(value);
+        }
+        else {
+            this._values[index] = value;
+        }
+    }
+    indexOf(address) {
+        for (let i = 0; i < this._keys.length; i++) {
+            const key = this._keys[i];
+            if (address.equals(key)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    has(key) {
+        for (let i = 0; i < this._keys.length; i++) {
+            if (key.equals(this._keys[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    get(key) {
+        const index = this.indexOf(key);
+        if (index == -1) {
+            throw new Error('Key not found in map');
+        }
+        return this._values[index];
+    }
+    delete(key) {
+        const index = this.indexOf(key);
+        if (index == -1) {
+            return false;
+        }
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+        return true;
+    }
+}

package/build/deterministic/AddressSet.d.ts

@@ -0,0 +1,13 @@
+import { i32 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+export declare class AddressSet {
+    private keys;
+    constructor(keys?: Address[]);
+    add(address: Address): void;
+    contains(address: Address): boolean;
+    remove(address: Address): void;
+    size(): i32;
+    clone(): AddressSet;
+    clear(): void;
+    combine(set: AddressSet): AddressSet;
+}

package/build/deterministic/AddressSet.js

@@ -0,0 +1,44 @@
+export class AddressSet {
+    constructor(keys = []) {
+        this.keys = keys;
+    }
+    add(address) {
+        if (!this.contains(address)) {
+            this.keys.push(address);
+        }
+    }
+    contains(address) {
+        for (let i = 0; i < this.keys.length; i++) {
+            if (this.keys[i].equals(address)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    remove(address) {
+        const index = this.keys.findIndex((key) => key.equals(address));
+        if (index !== -1) {
+            this.keys.splice(index, 1);
+        }
+    }
+    size() {
+        return this.keys.length;
+    }
+    clone() {
+        const clone = new AddressSet();
+        for (let i = 0; i < this.keys.length; i++) {
+            clone.add(this.keys[i]);
+        }
+        return clone;
+    }
+    clear() {
+        this.keys = [];
+    }
+    combine(set) {
+        const clone = this.clone();
+        for (let i = 0; i < set.keys.length; i++) {
+            clone.add(set.keys[i]);
+        }
+        return clone;
+    }
+}

package/build/deterministic/DeterministicMap.d.ts

@@ -0,0 +1,17 @@
+export declare class DeterministicMap<K, V> {
+    #private;
+    private compareFn;
+    private map;
+    constructor(compareFn: (a: K, b: K) => number);
+    get size(): number;
+    static fromMap<K, V>(map: Map<K, V>, compareFn: (a: K, b: K) => number): DeterministicMap<K, V>;
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    forEach(callback: (value: V, key: K, map: DeterministicMap<K, V>) => void): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}

package/build/deterministic/DeterministicMap.js

@@ -0,0 +1,83 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DeterministicMap_keys;
+export class DeterministicMap {
+    constructor(compareFn) {
+        this.compareFn = compareFn;
+        _DeterministicMap_keys.set(this, void 0);
+        this.map = new Map();
+        __classPrivateFieldSet(this, _DeterministicMap_keys, [], "f");
+    }
+    get size() {
+        return this.map.size;
+    }
+    static fromMap(map, compareFn) {
+        const deterministicMap = new DeterministicMap(compareFn);
+        for (const [key, value] of map) {
+            deterministicMap.set(key, value);
+        }
+        return deterministicMap;
+    }
+    set(key, value) {
+        if (!this.map.has(key)) {
+            __classPrivateFieldGet(this, _DeterministicMap_keys, "f").push(key);
+            __classPrivateFieldGet(this, _DeterministicMap_keys, "f").sort(this.compareFn);
+        }
+        this.map.set(key, value);
+    }
+    get(key) {
+        return this.map.get(key);
+    }
+    keys() {
+        return __classPrivateFieldGet(this, _DeterministicMap_keys, "f").values();
+    }
+    values() {
+        const values = [];
+        for (let i = 0; i < __classPrivateFieldGet(this, _DeterministicMap_keys, "f").length; i++) {
+            const key = __classPrivateFieldGet(this, _DeterministicMap_keys, "f")[i];
+            const value = this.map.get(key);
+            if (value) {
+                values.push(value);
+            }
+            else {
+                throw new Error('Value not found');
+            }
+        }
+        return values.values();
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    delete(key) {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+            __classPrivateFieldSet(this, _DeterministicMap_keys, __classPrivateFieldGet(this, _DeterministicMap_keys, "f").filter((k) => k !== key), "f");
+            return true;
+        }
+        return false;
+    }
+    clear() {
+        this.map.clear();
+        __classPrivateFieldSet(this, _DeterministicMap_keys, [], "f");
+    }
+    forEach(callback) {
+        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keys, "f")) {
+            const value = this.map.get(key);
+            callback(value, key, this);
+        }
+    }
+    *[(_DeterministicMap_keys = new WeakMap(), Symbol.iterator)]() {
+        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keys, "f")) {
+            yield [key, this.map.get(key)];
+        }
+    }
+}

package/build/deterministic/DeterministicSet.d.ts

@@ -0,0 +1,13 @@
+export declare class DeterministicSet<T> {
+    private compareFn;
+    private elements;
+    constructor(compareFn: (a: T, b: T) => number);
+    add(value: T): void;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+    clear(): void;
+    forEach(callback: (value: T, set: DeterministicSet<T>) => void): void;
+    static fromSet<T>(set: Set<T>, compareFn: (a: T, b: T) => number): DeterministicSet<T>;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<T>;
+}

package/build/deterministic/DeterministicSet.js

@@ -0,0 +1,46 @@
+export class DeterministicSet {
+    constructor(compareFn) {
+        this.compareFn = compareFn;
+        this.elements = [];
+    }
+    add(value) {
+        if (!this.elements.includes(value)) {
+            this.elements.push(value);
+            this.elements.sort(this.compareFn);
+        }
+    }
+    delete(value) {
+        const index = this.elements.indexOf(value);
+        if (index === -1) {
+            return false;
+        }
+        this.elements.splice(index, 1);
+        return true;
+    }
+    has(value) {
+        return this.elements.includes(value);
+    }
+    clear() {
+        this.elements = [];
+    }
+    forEach(callback) {
+        for (const value of this.elements) {
+            callback(value, this);
+        }
+    }
+    static fromSet(set, compareFn) {
+        const deterministicSet = new DeterministicSet(compareFn);
+        for (const value of set) {
+            deterministicSet.add(value);
+        }
+        return deterministicSet;
+    }
+    get size() {
+        return this.elements.length;
+    }
+    *[Symbol.iterator]() {
+        for (const value of this.elements) {
+            yield value;
+        }
+    }
+}

package/build/deterministic/Map.d.ts

@@ -0,0 +1,14 @@
+import { i32 } from '../utils/types.js';
+export declare class Map<K, V> {
+    protected _keys: K[];
+    protected _values: V[];
+    get size(): i32;
+    keys(): K[];
+    values(): V[];
+    set(key: K, value: V): void;
+    indexOf(key: K): i32;
+    get(key: K): V;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+}

package/build/deterministic/Map.js

@@ -0,0 +1,56 @@
+export class Map {
+    constructor() {
+        this._keys = [];
+        this._values = [];
+    }
+    get size() {
+        return this._keys.length;
+    }
+    keys() {
+        return this._keys;
+    }
+    values() {
+        return this._values;
+    }
+    set(key, value) {
+        const index = this.indexOf(key);
+        if (index == -1) {
+            this._keys.push(key);
+            this._values.push(value);
+        }
+        else {
+            this._values[index] = value;
+        }
+    }
+    indexOf(key) {
+        for (let i = 0; i < this._keys.length; i++) {
+            if (this._keys[i] == key) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    get(key) {
+        const index = this.indexOf(key);
+        if (index == -1) {
+            throw new Error('Key not found in map');
+        }
+        return this._values[index];
+    }
+    has(key) {
+        return this.indexOf(key) != -1;
+    }
+    delete(key) {
+        const index = this.indexOf(key);
+        if (index == -1) {
+            return false;
+        }
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+        return true;
+    }
+    clear() {
+        this._keys = [];
+        this._values = [];
+    }
+}

package/build/event/NetEvent.d.ts

@@ -0,0 +1,5 @@
+export declare class NetEvent {
+    readonly eventType: string;
+    readonly eventData: Uint8Array;
+    constructor(eventType: string, eventData: Uint8Array);
+}

package/build/event/NetEvent.js

@@ -0,0 +1,6 @@
+export class NetEvent {
+    constructor(eventType, eventData) {
+        this.eventType = eventType;
+        this.eventData = eventData;
+    }
+}

package/build/generators/AddressGenerator.d.ts

@@ -1,5 +1,8 @@
 import { Network } from 'bitcoinjs-lib';
 export declare class AddressGenerator {
     static generatePKSH(sha256Hash: Buffer, network: Network): string;
+    static generateTaprootAddress(pubKey: Buffer, network: {
+        bech32: string;
+    }): string;
     private static toSegwitAddress;
 }

package/build/generators/AddressGenerator.js

@@ -1,4 +1,4 @@
-import { bech32 } from 'bech32';
+import { bech32, bech32m } from 'bech32';
 import { initEccLib } from 'bitcoinjs-lib';
 import * as ecc from '@bitcoinerlab/secp256k1';
 import { ripemd160 } from 'bitcoinjs-lib/src/crypto.js';
@@ -10,6 +10,13 @@ export class AddressGenerator {
         const pkh = ripemd160(sha256Hash);
         return this.toSegwitAddress(pkh, network);
     }
+    static generateTaprootAddress(pubKey, network) {
+        if (pubKey.length !== 32)
+            throw new Error('Invalid public key length');
+        const words = bech32m.toWords(pubKey);
+        words.unshift(0x01);
+        return bech32m.encode(network.bech32, words);
+    }
     static toSegwitAddress(pkh, network) {
         const words = bech32.toWords(pkh);
         words.unshift(0x00);

package/build/keypair/Address.d.ts

@@ -0,0 +1,23 @@
+import { Network } from 'bitcoinjs-lib';
+import { ECPairInterface } from 'ecpair';
+export declare class Address extends Uint8Array {
+    #private;
+    private isP2TROnly;
+    constructor(bytes?: ArrayLike<number>);
+    private _keyPair;
+    get keyPair(): ECPairInterface;
+    static dead(): Address;
+    static fromString(pubKey: string): Address;
+    static wrap(bytes: ArrayLike<number>): Address;
+    toHex(): string;
+    equals(a: Address): boolean;
+    isBiggerThan(a: Address): boolean;
+    isSmallerThan(a: Address): boolean;
+    set(publicKey: ArrayLike<number>): void;
+    isValid(network: Network): boolean;
+    p2wpkh(network: Network): string;
+    p2pkh(network: Network): string;
+    p2shp2wpkh(network: Network): string;
+    toString(): string;
+    p2tr(network: Network): string;
+}

package/build/keypair/Address.js

@@ -0,0 +1,129 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Address_p2tr, _Address_network;
+import { EcKeyPair } from './EcKeyPair.js';
+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 {
+    constructor(bytes) {
+        super(ADDRESS_BYTE_LENGTH);
+        this.isP2TROnly = false;
+        _Address_p2tr.set(this, void 0);
+        _Address_network.set(this, void 0);
+        if (!bytes) {
+            return;
+        }
+        this.set(bytes);
+    }
+    get keyPair() {
+        if (!this._keyPair) {
+            throw new Error('Public key not set for address');
+        }
+        return this._keyPair;
+    }
+    static dead() {
+        return Address.fromString('0x04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f');
+    }
+    static fromString(pubKey) {
+        if (pubKey.startsWith('0x')) {
+            pubKey = pubKey.slice(2);
+        }
+        return new Address(Buffer.from(pubKey, 'hex'));
+    }
+    static wrap(bytes) {
+        return new Address(bytes);
+    }
+    toHex() {
+        return '0x' + Buffer.from(this).toString('hex');
+    }
+    equals(a) {
+        if (a.length !== this.length) {
+            return false;
+        }
+        for (let i = 0; i < this.length; i++) {
+            if (this[i] !== a[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isBiggerThan(a) {
+        for (let i = 0; i < this.length; i++) {
+            if (this[i] < a[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isSmallerThan(a) {
+        for (let i = 0; i < this.length; i++) {
+            if (this[i] > a[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    set(publicKey) {
+        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);
+            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));
+        }
+    }
+    isValid(network) {
+        return AddressVerificator.isValidPublicKey(Buffer.from(this).toString('hex'), network);
+    }
+    p2wpkh(network) {
+        return EcKeyPair.getP2WPKHAddress(this.keyPair, network);
+    }
+    p2pkh(network) {
+        return EcKeyPair.getLegacyAddress(this.keyPair, network);
+    }
+    p2shp2wpkh(network) {
+        return EcKeyPair.getLegacySegwitAddress(this.keyPair, network);
+    }
+    toString() {
+        if (__classPrivateFieldGet(this, _Address_p2tr, "f")) {
+            return __classPrivateFieldGet(this, _Address_p2tr, "f");
+        }
+        return this.toHex();
+    }
+    p2tr(network) {
+        if (__classPrivateFieldGet(this, _Address_p2tr, "f") && __classPrivateFieldGet(this, _Address_network, "f") === network) {
+            return __classPrivateFieldGet(this, _Address_p2tr, "f");
+        }
+        let p2trAddy;
+        if (this._keyPair) {
+            p2trAddy = EcKeyPair.getTaprootAddress(this.keyPair, network);
+        }
+        else if (this.isP2TROnly) {
+            p2trAddy = EcKeyPair.tweakedPubKeyBufferToAddress(this, network);
+        }
+        if (p2trAddy) {
+            __classPrivateFieldSet(this, _Address_network, network, "f");
+            __classPrivateFieldSet(this, _Address_p2tr, p2trAddy, "f");
+            return p2trAddy;
+        }
+        throw new Error('Public key not set');
+    }
+}
+_Address_p2tr = new WeakMap(), _Address_network = new WeakMap();

package/build/keypair/AddressVerificator.d.ts

@@ -1,5 +1,4 @@
 import { Network } from 'bitcoinjs-lib';
-import { Address } from '@btc-vision/bsi-binary';
 export declare enum AddressTypes {
     P2PKH = "P2PKH",
     P2SH = "P2SH",
@@ -10,7 +9,7 @@ export declare enum AddressTypes {
     P2WPKH = "P2WPKH"
 }
 export declare class AddressVerificator {
-    static isValidP2TRAddress(inAddress: Address, network: Network): boolean;
+    static isValidP2TRAddress(inAddress: string, network: Network): boolean;
     static isP2WPKHAddress(inAddress: string, network: Network): boolean;
     static isP2PKHOrP2SH(addy: string, network: Network): boolean;
     static isValidPublicKey(input: string, network: Network): boolean;

package/build/keypair/AddressVerificator.js

@@ -56,14 +56,19 @@ export class AddressVerificator {
                 input = input.slice(2);
             }
             const hexRegex = /^[0-9a-fA-F]+$/;
-            if ((input.length === 66 || input.length === 130) && hexRegex.test(input)) {
+            if (!hexRegex.test(input)) {
+                return false;
+            }
+            if (input.length === 64) {
+                return true;
+            }
+            if (input.length === 66 || input.length === 130) {
                 const pubKeyBuffer = Buffer.from(input, 'hex');
                 EcKeyPair.fromPublicKey(pubKeyBuffer, network);
                 return true;
             }
         }
         catch (error) {
-            console.log(error);
             return false;
         }
         return false;

package/build/keypair/EcKeyPair.d.ts

@@ -1,4 +1,3 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { BIP32API, BIP32Interface } from 'bip32';
 import { Network, Signer } from 'bitcoinjs-lib';
 import { ECPairAPI, ECPairInterface } from 'ecpair';
@@ -9,20 +8,21 @@ export declare class EcKeyPair {
     static fromWIF(wif: string, 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 generateMultiSigAddress(pubKeys: Buffer[], minimumSignatureRequired: number, network?: Network): string;
     static verifyPubKeys(pubKeys: Buffer[], network?: Network): Buffer[];
-    static getP2WPKHAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static getP2WPKHAddress(keyPair: ECPairInterface, network?: Network): string;
     static tweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string;
+    static tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer: Buffer | Uint8Array, 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 verifyContractAddress(contractAddress: string, network?: Network): boolean;
+    static getLegacySegwitAddress(keyPair: ECPairInterface, network?: Network): string;
+    static getLegacyAddress(keyPair: ECPairInterface, network?: Network): string;
+    static getP2PKAddress(keyPair: ECPairInterface, network?: Network): string;
     static generateRandomKeyPair(network?: Network): ECPairInterface;
     static fromSeed(seed: Buffer, network?: Network): BIP32Interface;
-    static getTaprootAddress(keyPair: ECPairInterface | Signer, network?: Network): Address;
-    static getTaprootAddressFromAddress(inAddr: Address, network?: Network): Address;
+    static getTaprootAddress(keyPair: ECPairInterface | Signer, network?: Network): string;
+    static getTaprootAddressFromAddress(inAddr: string, network?: Network): string;
     static fromSeedKeyPair(seed: Buffer, network?: Network): ECPairInterface;
 }

package/build/keypair/EcKeyPair.js

@@ -57,9 +57,16 @@ export class EcKeyPair {
         if (tweakedPubKeyHex.startsWith('0x')) {
             tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
         }
-        const tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        let tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        if (tweakedPubKeyBuffer.length !== 32)
+            tweakedPubKeyBuffer = toXOnly(tweakedPubKeyBuffer);
+        return EcKeyPair.tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer, network);
+    }
+    static tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer, network) {
         const { address } = payments.p2tr({
-            pubkey: toXOnly(tweakedPubKeyBuffer),
+            pubkey: Buffer.isBuffer(tweakedPubKeyBuffer)
+                ? tweakedPubKeyBuffer
+                : Buffer.from(tweakedPubKeyBuffer),
             network: network,
         });
         if (!address) {

package/build/keypair/Wallet.d.ts

@@ -1,20 +1,26 @@
 import { IWallet } from './interfaces/IWallet.js';
 import { ECPairInterface } from 'ecpair';
 import { Network } from 'bitcoinjs-lib';
-import { Address } from '@btc-vision/bsi-binary';
+import { Address } from './Address.js';
 export declare class Wallet {
     readonly network: Network;
     private readonly _keypair;
     private readonly _p2wpkh;
     private readonly _p2tr;
     private readonly _legacy;
+    private readonly _segwitLegacy;
     private readonly _bufferPubKey;
+    private readonly _tweakedKey;
+    private readonly _address;
     constructor(wallet: IWallet, network?: Network);
+    get address(): Address;
+    get tweakedPubKeyKey(): Buffer;
     get keypair(): ECPairInterface;
-    get p2wpkh(): Address;
-    get p2tr(): Address;
-    get legacy(): Address;
-    get addresses(): Address[];
+    get p2wpkh(): string;
+    get p2tr(): string;
+    get legacy(): string;
+    get addresses(): string[];
+    get segwitLegacy(): string;
     get publicKey(): Buffer;
     get xOnly(): Buffer;
     static fromWif(wif: string, network?: Network): Wallet;