@btc-vision/transaction 1.0.112 → 1.0.114

package/build/deterministic/AddressMap.d.ts

@@ -0,0 +1,10 @@
+import { i32 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+import { Map } from './Map.js';
+export declare class AddressMap<V> extends Map<Address, V> {
+    set(key: Address, value: V): void;
+    indexOf(address: Address): i32;
+    has(key: Address): boolean;
+    get(key: Address): V;
+    delete(key: Address): boolean;
+}

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,6 +1,17 @@
-import { networks } from 'bitcoinjs-lib';
-import { Address } from '@btc-vision/bsi-binary';
+import { Network } from 'bitcoinjs-lib';
+export declare enum AddressTypes {
+    P2PKH = "P2PKH",
+    P2SH = "P2SH",
+    P2SH_P2WPKH = "P2SH-P2WPKH",
+    P2SH_OR_P2SH_P2WPKH = "P2SH_OR_P2SH-P2WPKH",
+    P2PK = "P2PK",
+    P2TR = "P2TR",
+    P2WPKH = "P2WPKH"
+}
 export declare class AddressVerificator {
-    static isValidP2TRAddress(inAddress: Address, network: networks.Network): boolean;
-    static validatePKHAddress(inAddress: string, network: networks.Network): boolean;
+    static isValidP2TRAddress(inAddress: 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;
+    static validateBitcoinAddress(addy: string, network: Network): AddressTypes | null;
 }

package/build/keypair/AddressVerificator.js

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