@btc-vision/transaction 1.7.3 → 1.7.5

package/build/deterministic/Map.js

@@ -1,7 +1,7 @@
 export class Map {
     constructor() {
         this._keys = [];
-        this._values = [];
+        this._values = {};
     }
     get size() {
         return this._keys.length;
@@ -10,57 +10,65 @@ export class Map {
         yield* this._keys;
     }
     *values() {
-        yield* this._values;
+        for (const key of this._keys) {
+            yield this._values[this.keyToString(key)];
+        }
     }
     *entries() {
-        for (let i = 0; i < this._keys.length; i++) {
-            yield [this._keys[i], this._values[i]];
+        for (const key of this._keys) {
+            yield [key, this._values[this.keyToString(key)]];
         }
     }
     set(key, value) {
-        const index = this.indexOf(key);
-        if (index == -1) {
+        const keyStr = this.keyToString(key);
+        if (!this.has(key)) {
             this._keys.push(key);
-            this._values.push(value);
-        }
-        else {
-            this._values[index] = value;
         }
+        this._values[keyStr] = value;
     }
     indexOf(key) {
         for (let i = 0; i < this._keys.length; i++) {
-            if (this._keys[i] == key) {
+            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];
+        return this._values[this.keyToString(key)];
     }
     has(key) {
-        return this.indexOf(key) != -1;
+        return Object.prototype.hasOwnProperty.call(this._values, this.keyToString(key));
     }
     delete(key) {
         const index = this.indexOf(key);
-        if (index == -1) {
+        if (index === -1) {
             return false;
         }
+        const keyStr = this.keyToString(key);
         this._keys.splice(index, 1);
-        this._values.splice(index, 1);
+        delete this._values[keyStr];
         return true;
     }
     clear() {
         this._keys = [];
-        this._values = [];
+        this._values = {};
     }
     *[Symbol.iterator]() {
-        for (let i = 0; i < this._keys.length; i++) {
-            yield [this._keys[i], this._values[i]];
+        for (const key of this._keys) {
+            yield [key, this._values[this.keyToString(key)]];
+        }
+    }
+    keyToString(key) {
+        if (typeof key === 'string') {
+            return key;
+        }
+        if (typeof key === 'number' || typeof key === 'boolean') {
+            return String(key);
+        }
+        if (typeof key === 'object' && key !== null) {
+            return JSON.stringify(key);
         }
+        return String(key);
     }
 }

package/build/opnet.d.ts

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

package/build/opnet.js

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

package/package.json

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

package/src/deterministic/AddressMap.ts

@@ -3,11 +3,9 @@ import { Map } from './Map.js';
 
 export class AddressMap<V> {
     private items: Map<bigint, V>;
-    private keyOrder: Address[];
 
     constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null) {
         this.items = new Map();
-        this.keyOrder = [];
 
         if (iterable) {
             for (const [key, value] of iterable) {
@@ -17,15 +15,14 @@ export class AddressMap<V> {
     }
 
     public get size(): number {
-        return this.keyOrder.length;
+        return this.items.size;
     }
 
-    public set(key: Address, value: V): void {
+    public set(key: Address, value: V): this {
         const keyBigInt = key.toBigInt();
-        if (!this.items.has(keyBigInt)) {
-            this.keyOrder.push(key);
-        }
         this.items.set(keyBigInt, value);
+
+        return this;
     }
 
     public get(key: Address): V | undefined {
@@ -38,41 +35,35 @@ export class AddressMap<V> {
 
     public delete(key: Address): boolean {
         const keyBigInt = key.toBigInt();
-        if (this.items.delete(keyBigInt)) {
-            this.keyOrder = this.keyOrder.filter((k) => k.toBigInt() !== keyBigInt);
-            return true;
-        }
-        return false;
+        return this.items.delete(keyBigInt);
     }
 
     public clear(): void {
         this.items.clear();
-        this.keyOrder = [];
     }
 
     public indexOf(address: Address): number {
-        const addressBigInt = address.toBigInt();
-        for (let i: number = 0; i < this.keyOrder.length; i++) {
-            if (this.keyOrder[i].toBigInt() === addressBigInt) {
-                return i;
-            }
-        }
-        return -1;
+        return this.items.indexOf(address.toBigInt());
     }
 
+    /**
+     * WARNING, THIS RETURN NEW COPY OF THE KEYS
+     */
     *entries(): IterableIterator<[Address, V]> {
-        for (const key of this.keyOrder) {
-            yield [key, this.items.get(key.toBigInt()) as V];
+        for (const [keyBigInt, value] of this.items.entries()) {
+            yield [Address.fromBigInt(keyBigInt), value];
         }
     }
 
     *keys(): IterableIterator<Address> {
-        yield* this.keyOrder;
+        for (const keyBigInt of this.items.keys()) {
+            yield Address.fromBigInt(keyBigInt);
+        }
     }
 
     *values(): IterableIterator<V> {
-        for (const key of this.keyOrder) {
-            yield this.items.get(key.toBigInt()) as V;
+        for (const value of this.items.values()) {
+            yield value;
         }
     }
 
@@ -80,15 +71,13 @@ export class AddressMap<V> {
         callback: (value: V, key: Address, map: AddressMap<V>) => void,
         thisArg?: unknown,
     ): void {
-        for (const key of this.keyOrder) {
-            callback.call(thisArg, this.items.get(key.toBigInt()) as V, key, this);
+        for (const [keyBigInt, value] of this.items.entries()) {
+            const key = Address.fromBigInt(keyBigInt);
+            callback.call(thisArg, value, key, this);
         }
     }
 
     *[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];
-        }
+        yield* this.entries();
     }
 }

package/src/deterministic/CustomMap.ts

@@ -0,0 +1,316 @@
+export class CustomMap<K, V> {
+    private static readonly INITIAL_CAPACITY = 16;
+    private static readonly LOAD_FACTOR = 0.75;
+
+    #keys: (K | undefined)[];
+    #values: (V | undefined)[];
+
+    private deleted: boolean[];
+    private capacity: number;
+
+    constructor() {
+        this.capacity = CustomMap.INITIAL_CAPACITY;
+        this.#keys = new Array<K>(this.capacity);
+        this.#values = new Array<V>(this.capacity);
+        this.deleted = new Array<boolean>(this.capacity).fill(false);
+    }
+
+    private _size: number = 0;
+
+    public get size(): number {
+        return this._size;
+    }
+
+    public set(key: K, value: V): boolean {
+        let exist: boolean = true;
+
+        const index = this.findInsertIndex(key);
+        if (this.#keys[index] === undefined || this.deleted[index]) {
+            this._size++;
+            exist = false;
+        }
+
+        this.#keys[index] = key;
+        this.#values[index] = value;
+        this.deleted[index] = false;
+
+        if (this._size > this.capacity * CustomMap.LOAD_FACTOR) {
+            this.resize();
+        }
+
+        return exist;
+    }
+
+    public get(key: K): V | undefined {
+        const index = this.findIndex(key);
+        return index === -1 ? undefined : this.#values[index];
+    }
+
+    public has(key: K): boolean {
+        return this.findIndex(key) !== -1;
+    }
+
+    public indexOf(key: K): number {
+        return this.findIndex(key);
+    }
+
+    public delete(key: K): boolean {
+        const index = this.findIndex(key);
+
+        if (index === -1) {
+            return false;
+        }
+
+        this.#keys[index] = undefined;
+        this.#values[index] = undefined;
+        this.deleted[index] = true;
+        this._size--;
+
+        return true;
+    }
+
+    public clear(): void {
+        this.#keys = new Array<K>(this.capacity);
+        this.#values = new Array<V>(this.capacity);
+        this.deleted = new Array<boolean>(this.capacity).fill(false);
+        this._size = 0;
+    }
+
+    public *entries(): MapIterator<[K, V]> {
+        for (let i = 0; i < this.capacity; i++) {
+            if (this.#keys[i] !== undefined && !this.deleted[i]) {
+                yield [this.#keys[i] as K, this.#values[i] as V];
+            }
+        }
+    }
+
+    public *keys(): MapIterator<K> {
+        for (let i = 0; i < this.capacity; i++) {
+            if (this.#keys[i] !== undefined && !this.deleted[i]) {
+                yield this.#keys[i] as K;
+            }
+        }
+    }
+
+    public *values(): MapIterator<V> {
+        for (let i = 0; i < this.capacity; i++) {
+            if (this.#keys[i] !== undefined && !this.deleted[i]) {
+                yield this.#values[i] as V;
+            }
+        }
+    }
+
+    *[Symbol.iterator](): MapIterator<[K, V]> {
+        yield* this.entries();
+    }
+
+    private hashBigInt(key: bigint): number {
+        // For small bigints that fit in 32 bits, use direct conversion
+        if (key >= -2147483648n && key <= 2147483647n) {
+            return Number(key) | 0;
+        }
+
+        // For larger bigints, use bit manipulation
+        // Mix high and low 32-bit parts
+        let hash = 2166136261; // FNV-1a initial value
+
+        // Process the bigint in 32-bit chunks
+        let n = key < 0n ? -key : key;
+
+        while (n > 0n) {
+            // Extract 32-bit chunk
+            const chunk = Number(n & 0xffffffffn);
+            hash ^= chunk;
+            hash = Math.imul(hash, 16777619);
+            n = n >> 32n;
+        }
+
+        // Mix in the sign
+        if (key < 0n) {
+            hash ^= 0x80000000;
+            hash = Math.imul(hash, 16777619);
+        }
+
+        return Math.abs(hash);
+    }
+
+    private hash(key: K): number {
+        let hash = 0;
+
+        switch (typeof key) {
+            case 'number':
+                // Handle NaN and infinity specially
+                if (key !== key) return 0x7ff8000000000000; // NaN
+                if (!isFinite(key)) return key > 0 ? 0x7ff0000000000000 : 0xfff0000000000000;
+                // Use the number itself as hash
+                hash = key | 0; // Convert to 32-bit integer
+                break;
+
+            case 'string':
+                // FNV-1a hash for strings
+                hash = 2166136261;
+                for (let i = 0; i < (key as string).length; i++) {
+                    hash ^= (key as string).charCodeAt(i);
+                    hash = Math.imul(hash, 16777619);
+                }
+                break;
+
+            case 'boolean':
+                hash = key ? 1231 : 1237;
+                break;
+
+            case 'symbol': {
+                // Symbols need special handling - use description
+                const desc = (key as symbol).description || '';
+                hash = this.hash(desc as K); // Recursive call with string
+                break;
+            }
+
+            case 'bigint':
+                // Convert bigint to string for hashing
+                hash = this.hashBigInt(key);
+                break;
+
+            case 'undefined':
+                hash = 0;
+                break;
+
+            case 'object':
+                if (key === null) {
+                    hash = 0;
+                } else if (key instanceof Date) {
+                    hash = key.getTime() | 0;
+                } else if (ArrayBuffer.isView(key) || key instanceof ArrayBuffer) {
+                    // Handle Buffer, TypedArrays, ArrayBuffer
+                    hash = this.hashBuffer(key);
+                } else if (Array.isArray(key)) {
+                    // Hash arrays by combining element hashes
+                    hash = 1;
+                    for (const item of key) {
+                        hash = Math.imul(hash, 31) + this.hash(item as K);
+                    }
+                } else {
+                    throw new Error('Raw object not supported.');
+                    // For objects, we need reference equality
+                    // So we'll use linear probing with === comparison
+                    // Start with a random-ish position
+                    //hash = 0x42424242;
+                }
+                break;
+
+            case 'function':
+                // Hash function by its string representation
+                hash = this.hash(key.toString() as K);
+                break;
+        }
+
+        // Ensure positive index
+        return Math.abs(hash) % this.capacity;
+    }
+
+    private hashBuffer(buffer: ArrayBuffer | object): number {
+        let bytes: Uint8Array;
+
+        if (buffer instanceof ArrayBuffer) {
+            bytes = new Uint8Array(buffer);
+        } else if (ArrayBuffer.isView(buffer)) {
+            bytes = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        } else {
+            return 0;
+        }
+
+        // FNV-1a hash for bytes
+        let hash = 2166136261;
+        for (let i = 0; i < Math.min(bytes.length, 100); i++) {
+            // Cap at 100 bytes for performance
+            hash ^= bytes[i];
+            hash = Math.imul(hash, 16777619);
+        }
+        return hash;
+    }
+
+    private equals(a: K, b: K): boolean {
+        // Handle special cases
+        if (a === b) return true;
+
+        // NaN === NaN should be true for map #keys
+        if (typeof a === 'number' && typeof b === 'number' && a !== a && b !== b) {
+            return true;
+        }
+
+        // For buffers, do deep comparison
+        if (
+            (ArrayBuffer.isView(a) || a instanceof ArrayBuffer) &&
+            (ArrayBuffer.isView(b) || b instanceof ArrayBuffer)
+        ) {
+            return this.buffersEqual(a, b);
+        }
+
+        return false;
+    }
+
+    private buffersEqual(a: ArrayBuffer | object, b: ArrayBuffer | object): boolean {
+        const bytesA = this.getBytes(a);
+        const bytesB = this.getBytes(b);
+
+        if (bytesA.length !== bytesB.length) return false;
+
+        for (let i = 0; i < bytesA.length; i++) {
+            if (bytesA[i] !== bytesB[i]) return false;
+        }
+
+        return true;
+    }
+
+    private getBytes(buffer: ArrayBuffer | object): Uint8Array {
+        if (buffer instanceof ArrayBuffer) {
+            return new Uint8Array(buffer);
+        } else if (ArrayBuffer.isView(buffer)) {
+            return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        }
+        return new Uint8Array(0);
+    }
+
+    private findIndex(key: K): number {
+        let index = this.hash(key);
+
+        while (this.#keys[index] !== undefined || this.deleted[index]) {
+            if (this.#keys[index] !== undefined && this.equals(this.#keys[index] as K, key)) {
+                return index;
+            }
+            index = (index + 1) % this.capacity;
+        }
+
+        return -1;
+    }
+
+    private findInsertIndex(key: K): number {
+        let index = this.hash(key);
+
+        while (this.#keys[index] !== undefined && !this.deleted[index]) {
+            if (this.equals(this.#keys[index] as K, key)) {
+                return index; // Key already exists
+            }
+            index = (index + 1) % this.capacity;
+        }
+
+        return index;
+    }
+
+    private resize(): void {
+        const oldKeys = this.#keys;
+        const oldValues = this.#values;
+
+        this.capacity *= 2;
+        this.#keys = new Array<K>(this.capacity);
+        this.#values = new Array<V>(this.capacity);
+        this.deleted = new Array<boolean>(this.capacity).fill(false);
+        this._size = 0;
+
+        for (let i = 0; i < oldKeys.length; i++) {
+            if (oldKeys[i] !== undefined && !this.deleted[i]) {
+                this.set(oldKeys[i] as K, oldValues[i] as V);
+            }
+        }
+    }
+}

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