@btc-vision/transaction 1.7.3 → 1.7.4

package/browser/src/deterministic/DeterministicSet.d.ts

@@ -2,12 +2,14 @@ export declare class DeterministicSet<T> {
     private compareFn;
     private elements;
     constructor(compareFn: (a: T, b: T) => number);
+    get size(): number;
+    static fromSet<T>(set: Set<T>, compareFn: (a: T, b: T) => number): DeterministicSet<T>;
     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;
+    values(): IterableIterator<T>;
     [Symbol.iterator](): IterableIterator<T>;
+    private binarySearch;
 }

package/browser/src/deterministic/Map.d.ts

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

package/build/deterministic/DeterministicMap.js

@@ -30,8 +30,17 @@ export class DeterministicMap {
     }
     set(key, value) {
         if (!this.map.has(key)) {
-            __classPrivateFieldGet(this, _DeterministicMap_keys, "f").push(key);
-            __classPrivateFieldGet(this, _DeterministicMap_keys, "f").sort(this.compareFn);
+            let left = 0, right = __classPrivateFieldGet(this, _DeterministicMap_keys, "f").length;
+            while (left < right) {
+                const mid = Math.floor((left + right) / 2);
+                if (this.compareFn(__classPrivateFieldGet(this, _DeterministicMap_keys, "f")[mid], key) < 0) {
+                    left = mid + 1;
+                }
+                else {
+                    right = mid;
+                }
+            }
+            __classPrivateFieldGet(this, _DeterministicMap_keys, "f").splice(left, 0, key);
         }
         this.map.set(key, value);
     }
@@ -61,8 +70,21 @@ export class DeterministicMap {
     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;
+            let left = 0, right = __classPrivateFieldGet(this, _DeterministicMap_keys, "f").length - 1;
+            while (left <= right) {
+                const mid = Math.floor((left + right) / 2);
+                const cmp = this.compareFn(__classPrivateFieldGet(this, _DeterministicMap_keys, "f")[mid], key);
+                if (cmp === 0) {
+                    __classPrivateFieldGet(this, _DeterministicMap_keys, "f").splice(mid, 1);
+                    return true;
+                }
+                else if (cmp < 0) {
+                    left = mid + 1;
+                }
+                else {
+                    right = mid - 1;
+                }
+            }
         }
         return false;
     }

package/build/deterministic/DeterministicSet.d.ts

@@ -2,12 +2,14 @@ export declare class DeterministicSet<T> {
     private compareFn;
     private elements;
     constructor(compareFn: (a: T, b: T) => number);
+    get size(): number;
+    static fromSet<T>(set: Set<T>, compareFn: (a: T, b: T) => number): DeterministicSet<T>;
     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;
+    values(): IterableIterator<T>;
     [Symbol.iterator](): IterableIterator<T>;
+    private binarySearch;
 }

package/build/deterministic/DeterministicSet.js

@@ -3,22 +3,32 @@ export class DeterministicSet {
         this.compareFn = compareFn;
         this.elements = [];
     }
+    get size() {
+        return this.elements.length;
+    }
+    static fromSet(set, compareFn) {
+        const deterministicSet = new DeterministicSet(compareFn);
+        for (const value of set) {
+            deterministicSet.add(value);
+        }
+        return deterministicSet;
+    }
     add(value) {
-        if (!this.elements.includes(value)) {
-            this.elements.push(value);
-            this.elements.sort(this.compareFn);
+        const { found, index } = this.binarySearch(value);
+        if (!found) {
+            this.elements.splice(index, 0, value);
         }
     }
     delete(value) {
-        const index = this.elements.indexOf(value);
-        if (index === -1) {
-            return false;
+        const { found, index } = this.binarySearch(value);
+        if (found) {
+            this.elements.splice(index, 1);
+            return true;
         }
-        this.elements.splice(index, 1);
-        return true;
+        return false;
     }
     has(value) {
-        return this.elements.includes(value);
+        return this.binarySearch(value).found;
     }
     clear() {
         this.elements = [];
@@ -28,19 +38,27 @@ export class DeterministicSet {
             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;
+    *values() {
+        yield* this.elements;
     }
     *[Symbol.iterator]() {
-        for (const value of this.elements) {
-            yield value;
+        yield* this.elements;
+    }
+    binarySearch(value) {
+        let left = 0, right = this.elements.length;
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2);
+            const cmp = this.compareFn(this.elements[mid], value);
+            if (cmp === 0) {
+                return { found: true, index: mid };
+            }
+            else if (cmp < 0) {
+                left = mid + 1;
+            }
+            else {
+                right = mid;
+            }
         }
+        return { found: false, index: left };
     }
 }

package/build/deterministic/Map.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.7.3",
+    "version": "1.7.4",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/deterministic/DeterministicMap.ts

@@ -26,8 +26,18 @@ export class DeterministicMap<K, V> {
 
     public set(key: K, value: V): void {
         if (!this.map.has(key)) {
-            this.#keys.push(key);
-            this.#keys.sort(this.compareFn);
+            // Binary search for insertion position
+            let left = 0,
+                right = this.#keys.length;
+            while (left < right) {
+                const mid = Math.floor((left + right) / 2);
+                if (this.compareFn(this.#keys[mid], key) < 0) {
+                    left = mid + 1;
+                } else {
+                    right = mid;
+                }
+            }
+            this.#keys.splice(left, 0, key);
         }
         this.map.set(key, value);
     }
@@ -64,8 +74,24 @@ export class DeterministicMap<K, V> {
     public delete(key: K): boolean {
         if (this.map.has(key)) {
             this.map.delete(key);
-            this.#keys = this.#keys.filter((k) => k !== key);
-            return true;
+
+            // Binary search to find the key's index
+            let left = 0,
+                right = this.#keys.length - 1;
+            while (left <= right) {
+                const mid = Math.floor((left + right) / 2);
+                const cmp = this.compareFn(this.#keys[mid], key);
+
+                if (cmp === 0) {
+                    // Found it, remove at this index
+                    this.#keys.splice(mid, 1);
+                    return true;
+                } else if (cmp < 0) {
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
         }
         return false;
     }

package/src/deterministic/DeterministicSet.ts

@@ -5,25 +5,39 @@ export class DeterministicSet<T> {
         this.elements = [];
     }
 
+    public get size(): number {
+        return this.elements.length;
+    }
+
+    public static fromSet<T>(set: Set<T>, compareFn: (a: T, b: T) => number): DeterministicSet<T> {
+        const deterministicSet = new DeterministicSet<T>(compareFn);
+        for (const value of set) {
+            deterministicSet.add(value);
+        }
+        return deterministicSet;
+    }
+
     public add(value: T): void {
-        if (!this.elements.includes(value)) {
-            this.elements.push(value);
-            this.elements.sort(this.compareFn);
+        const { found, index } = this.binarySearch(value);
+
+        if (!found) {
+            this.elements.splice(index, 0, value);
         }
     }
 
     public delete(value: T): boolean {
-        const index = this.elements.indexOf(value);
-        if (index === -1) {
-            return false;
+        const { found, index } = this.binarySearch(value);
+
+        if (found) {
+            this.elements.splice(index, 1);
+            return true;
         }
 
-        this.elements.splice(index, 1);
-        return true;
+        return false;
     }
 
     public has(value: T): boolean {
-        return this.elements.includes(value);
+        return this.binarySearch(value).found;
     }
 
     public clear(): void {
@@ -36,21 +50,30 @@ export class DeterministicSet<T> {
         }
     }
 
-    public static fromSet<T>(set: Set<T>, compareFn: (a: T, b: T) => number): DeterministicSet<T> {
-        const deterministicSet = new DeterministicSet<T>(compareFn);
-        for (const value of set) {
-            deterministicSet.add(value);
-        }
-        return deterministicSet;
+    *values(): IterableIterator<T> {
+        yield* this.elements;
     }
 
-    public get size(): number {
-        return this.elements.length;
+    *[Symbol.iterator](): IterableIterator<T> {
+        yield* this.elements;
     }
 
-    *[Symbol.iterator](): IterableIterator<T> {
-        for (const value of this.elements) {
-            yield value;
+    private binarySearch(value: T): { found: boolean; index: number } {
+        let left = 0, right = this.elements.length;
+
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2);
+            const cmp = this.compareFn(this.elements[mid], value);
+
+            if (cmp === 0) {
+                return { found: true, index: mid };
+            } else if (cmp < 0) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
         }
+
+        return { found: false, index: left };
     }
 }

package/src/deterministic/Map.ts

@@ -1,10 +1,8 @@
-import { i32 } from '../utils/types.js';
-
 export class Map<K, V> {
     protected _keys: K[] = [];
     protected _values: V[] = [];
 
-    public get size(): i32 {
+    public get size(): number {
         return this._keys.length;
     }
 
@@ -17,13 +15,13 @@ export class Map<K, V> {
     }
 
     public *entries(): IterableIterator<[K, V]> {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
+        for (let i: number = 0; i < this._keys.length; i++) {
             yield [this._keys[i], this._values[i]];
         }
     }
 
     public set(key: K, value: V): void {
-        const index: i32 = this.indexOf(key);
+        const index: number = this.indexOf(key);
         if (index == -1) {
             this._keys.push(key);
             this._values.push(value);
@@ -32,8 +30,8 @@ export class Map<K, V> {
         }
     }
 
-    public indexOf(key: K): i32 {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
+    public indexOf(key: K): number {
+        for (let i: number = 0; i < this._keys.length; i++) {
             if (this._keys[i] == key) {
                 return i;
             }
@@ -43,7 +41,7 @@ export class Map<K, V> {
     }
 
     public get(key: K): V | undefined {
-        const index: i32 = this.indexOf(key);
+        const index: number = this.indexOf(key);
         if (index == -1) {
             return undefined;
         }
@@ -55,7 +53,7 @@ export class Map<K, V> {
     }
 
     public delete(key: K): boolean {
-        const index: i32 = this.indexOf(key);
+        const index: number = this.indexOf(key);
         if (index == -1) {
             return false;
         }
@@ -71,7 +69,7 @@ export class Map<K, V> {
     }
 
     *[Symbol.iterator](): IterableIterator<[K, V]> {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
+        for (let i: number = 0; i < this._keys.length; i++) {
             yield [this._keys[i], this._values[i]];
         }
     }