@btc-vision/transaction 1.7.2 → 1.7.4

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

@@ -1,12 +1,14 @@
+import { Map } from './Map.js';
 export declare class DeterministicMap<K, V> {
     #private;
+    private compareFn;
     private map;
-    private readonly compareFn;
     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;
+    entries(): IterableIterator<[K, V]>;
     keys(): IterableIterator<K>;
     values(): IterableIterator<V>;
     has(key: K): boolean;

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

@@ -0,0 +1,15 @@
+export declare class Map<K, V> {
+    protected _keys: K[];
+    protected _values: V[];
+    get size(): number;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    set(key: K, value: V): void;
+    indexOf(key: K): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}

package/browser/src/opnet.d.ts

@@ -75,6 +75,7 @@ export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
 export * from './keypair/Secp256k1PointDeriver.js';
 export * from './transaction/ContractAddress.js';
+export * from './deterministic/Map.js';
 declare global {
     interface Window {
         unisat?: Unisat;

package/build/deterministic/AddressMap.js

@@ -1,3 +1,4 @@
+import { Map } from './Map.js';
 export class AddressMap {
     constructor(iterable) {
         this.items = new Map();
@@ -63,7 +64,10 @@ export class AddressMap {
             callback.call(thisArg, this.items.get(key.toBigInt()), key, this);
         }
     }
-    [Symbol.iterator]() {
-        return this.entries();
+    *[Symbol.iterator]() {
+        for (let i = 0; i < this.keyOrder.length; i++) {
+            const key = this.keyOrder[i];
+            yield [key, this.items.get(key.toBigInt())];
+        }
     }
 }

package/build/deterministic/DeterministicMap.d.ts

@@ -1,12 +1,14 @@
+import { Map } from './Map.js';
 export declare class DeterministicMap<K, V> {
     #private;
+    private compareFn;
     private map;
-    private readonly compareFn;
     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;
+    entries(): IterableIterator<[K, V]>;
     keys(): IterableIterator<K>;
     values(): IterableIterator<V>;
     has(key: K): boolean;

package/build/deterministic/DeterministicMap.js

@@ -9,13 +9,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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_keyOrder;
+var _DeterministicMap_keys;
+import { Map } from './Map.js';
 export class DeterministicMap {
     constructor(compareFn) {
-        _DeterministicMap_keyOrder.set(this, void 0);
-        this.map = new Map();
-        __classPrivateFieldSet(this, _DeterministicMap_keyOrder, [], "f");
         this.compareFn = compareFn;
+        _DeterministicMap_keys.set(this, void 0);
+        this.map = new Map();
+        __classPrivateFieldSet(this, _DeterministicMap_keys, [], "f");
     }
     get size() {
         return this.map.size;
@@ -29,30 +30,39 @@ export class DeterministicMap {
     }
     set(key, value) {
         if (!this.map.has(key)) {
-            __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f").push(key);
-            __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "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);
     }
     get(key) {
         return this.map.get(key);
     }
-    keys() {
-        return __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f").values();
+    *entries() {
+        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keys, "f")) {
+            yield [key, this.map.get(key)];
+        }
+    }
+    *keys() {
+        yield* __classPrivateFieldGet(this, _DeterministicMap_keys, "f");
     }
-    values() {
-        const values = [];
-        for (let i = 0; i < __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f").length; i++) {
-            const key = __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f")[i];
+    *values() {
+        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keys, "f")) {
             const value = this.map.get(key);
-            if (value !== undefined) {
-                values.push(value);
-            }
-            else {
+            if (value === undefined && !this.map.has(key)) {
                 throw new Error('Value not found');
             }
+            yield value;
         }
-        return values.values();
     }
     has(key) {
         return this.map.has(key);
@@ -60,23 +70,36 @@ export class DeterministicMap {
     delete(key) {
         if (this.map.has(key)) {
             this.map.delete(key);
-            __classPrivateFieldSet(this, _DeterministicMap_keyOrder, __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "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;
     }
     clear() {
         this.map.clear();
-        __classPrivateFieldSet(this, _DeterministicMap_keyOrder, [], "f");
+        __classPrivateFieldSet(this, _DeterministicMap_keys, [], "f");
     }
     forEach(callback) {
-        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f")) {
+        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keys, "f")) {
             const value = this.map.get(key);
             callback(value, key, this);
         }
     }
-    *[(_DeterministicMap_keyOrder = new WeakMap(), Symbol.iterator)]() {
-        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f")) {
+    *[(_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

@@ -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

@@ -0,0 +1,15 @@
+export declare class Map<K, V> {
+    protected _keys: K[];
+    protected _values: V[];
+    get size(): number;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    set(key: K, value: V): void;
+    indexOf(key: K): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}

package/build/deterministic/Map.js

@@ -0,0 +1,66 @@
+export class Map {
+    constructor() {
+        this._keys = [];
+        this._values = [];
+    }
+    get size() {
+        return this._keys.length;
+    }
+    *keys() {
+        yield* this._keys;
+    }
+    *values() {
+        yield* this._values;
+    }
+    *entries() {
+        for (let i = 0; i < this._keys.length; i++) {
+            yield [this._keys[i], this._values[i]];
+        }
+    }
+    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) {
+            return undefined;
+        }
+        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 = [];
+    }
+    *[Symbol.iterator]() {
+        for (let i = 0; i < this._keys.length; i++) {
+            yield [this._keys[i], this._values[i]];
+        }
+    }
+}

package/build/opnet.d.ts

@@ -75,6 +75,7 @@ export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
 export * from './keypair/Secp256k1PointDeriver.js';
 export * from './transaction/ContractAddress.js';
+export * from './deterministic/Map.js';
 declare global {
     interface Window {
         unisat?: Unisat;

package/build/opnet.js

@@ -74,3 +74,4 @@ export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
 export * from './keypair/Secp256k1PointDeriver.js';
 export * from './transaction/ContractAddress.js';
+export * from './deterministic/Map.js';

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.7.2",
+    "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/AddressMap.ts

@@ -1,4 +1,5 @@
 import { Address } from '../keypair/Address.js';
+import { Map } from './Map.js';
 
 export class AddressMap<V> {
     private items: Map<bigint, V>;
@@ -15,7 +16,7 @@ export class AddressMap<V> {
         }
     }
 
-    get size(): number {
+    public get size(): number {
         return this.keyOrder.length;
     }
 
@@ -84,7 +85,10 @@ export class AddressMap<V> {
         }
     }
 
-    [Symbol.iterator](): IterableIterator<[Address, V]> {
-        return this.entries();
+    *[Symbol.iterator](): IterableIterator<[Address, V]> {
+        for (let i = 0; i < this.keyOrder.length; i++) {
+            const key = this.keyOrder[i];
+            yield [key, this.items.get(key.toBigInt()) as V];
+        }
     }
 }

package/src/deterministic/DeterministicMap.ts

@@ -1,13 +1,12 @@
+import { Map } from './Map.js';
+
 export class DeterministicMap<K, V> {
     private map: Map<K, V>;
-    private readonly compareFn: (a: K, b: K) => number;
-
-    #keyOrder: K[];
+    #keys: K[];
 
-    constructor(compareFn: (a: K, b: K) => number) {
+    constructor(private compareFn: (a: K, b: K) => number) {
         this.map = new Map<K, V>();
-        this.#keyOrder = [];
-        this.compareFn = compareFn;
+        this.#keys = [];
     }
 
     public get size(): number {
@@ -27,8 +26,18 @@ export class DeterministicMap<K, V> {
 
     public set(key: K, value: V): void {
         if (!this.map.has(key)) {
-            this.#keyOrder.push(key);
-            this.#keyOrder.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);
     }
@@ -37,25 +46,25 @@ export class DeterministicMap<K, V> {
         return this.map.get(key);
     }
 
-    public keys(): IterableIterator<K> {
-        return this.#keyOrder.values();
+    public *entries(): IterableIterator<[K, V]> {
+        for (const key of this.#keys) {
+            yield [key, this.map.get(key) as V];
+        }
     }
 
-    public values(): IterableIterator<V> {
-        const values: V[] = [];
+    public *keys(): IterableIterator<K> {
+        yield* this.#keys;
+    }
 
-        for (let i = 0; i < this.#keyOrder.length; i++) {
-            const key = this.#keyOrder[i];
+    public *values(): IterableIterator<V> {
+        for (const key of this.#keys) {
             const value = this.map.get(key);
-
-            if (value !== undefined) {
-                values.push(value);
-            } else {
+            if (value === undefined && !this.map.has(key)) {
                 throw new Error('Value not found');
             }
-        }
 
-        return values.values();
+            yield value as V;
+        }
     }
 
     public has(key: K): boolean {
@@ -65,26 +74,42 @@ export class DeterministicMap<K, V> {
     public delete(key: K): boolean {
         if (this.map.has(key)) {
             this.map.delete(key);
-            this.#keyOrder = this.#keyOrder.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;
     }
 
     public clear(): void {
         this.map.clear();
-        this.#keyOrder = [];
+        this.#keys = [];
     }
 
     public forEach(callback: (value: V, key: K, map: DeterministicMap<K, V>) => void): void {
-        for (const key of this.#keyOrder) {
+        for (const key of this.#keys) {
             const value = this.map.get(key) as V;
             callback(value, key, this);
         }
     }
 
     *[Symbol.iterator](): IterableIterator<[K, V]> {
-        for (const key of this.#keyOrder) {
+        for (const key of this.#keys) {
             yield [key, this.map.get(key) as V];
         }
     }

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 };
     }
 }