@btc-vision/transaction 1.7.5 → 1.7.7

package/browser/src/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.1";
+export declare const version = "1.7.7";

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

@@ -1,11 +1,11 @@
-import { Map } from './Map.js';
-export declare class DeterministicMap<K, V> {
+import { FastMap, PropertyExtendedKey } from './FastMap.js';
+export declare class DeterministicMap<K extends PropertyExtendedKey, 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>;
+    static fromMap<K extends PropertyExtendedKey, V>(map: FastMap<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]>;

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

@@ -0,0 +1,24 @@
+export type PropertyExtendedKey = PropertyKey | bigint;
+export type FastRecord<V> = {
+    [key: string]: V;
+};
+export type IndexKey = string | number;
+export declare class FastMap<K extends PropertyExtendedKey, V> {
+    protected _keys: K[];
+    protected _values: FastRecord<V>;
+    constructor(iterable?: ReadonlyArray<readonly [K, V]> | null | FastMap<K, V>);
+    get size(): number;
+    setAll(map: FastMap<K, V>): void;
+    addAll(map: FastMap<K, V>): void;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    set(key: K, value: V): this;
+    indexOf(key: K): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    forEach(callback: (value: V, key: K, map: FastMap<K, V>) => void, thisArg?: unknown): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}

package/browser/src/opnet.d.ts

@@ -75,7 +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';
+export * from './deterministic/FastMap.js';
 export * from './deterministic/CustomMap.js';
 declare global {
     interface Window {

package/browser/test/fastmap-setall.test.d.ts

@@ -0,0 +1 @@
+export {};

package/browser/test/fastmap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/browser/test/old/FastBigIntMap.d.ts

@@ -0,0 +1,18 @@
+export declare class FastBigIntMap {
+    private items;
+    private keyOrder;
+    constructor(iterable?: ReadonlyArray<readonly [bigint, bigint]> | null | FastBigIntMap);
+    get size(): number;
+    setAll(map: FastBigIntMap): void;
+    addAll(map: FastBigIntMap): void;
+    set(key: bigint, value: bigint): this;
+    get(key: bigint): bigint | undefined;
+    has(key: bigint): boolean;
+    delete(key: bigint): boolean;
+    clear(): void;
+    entries(): IterableIterator<[bigint, bigint]>;
+    keys(): IterableIterator<bigint>;
+    values(): IterableIterator<bigint>;
+    forEach(callback: (value: bigint, key: bigint, map: FastBigIntMap) => void, thisArg?: unknown): void;
+    [Symbol.iterator](): IterableIterator<[bigint, bigint]>;
+}

package/browser/test/oldfastmap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.1";
+export declare const version = "1.7.7";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.7.1';
+export const version = '1.7.7';

package/build/deterministic/AddressMap.js

@@ -1,8 +1,8 @@
 import { Address } from '../keypair/Address.js';
-import { Map } from './Map.js';
+import { FastMap } from './FastMap.js';
 export class AddressMap {
     constructor(iterable) {
-        this.items = new Map();
+        this.items = new FastMap();
         if (iterable) {
             for (const [key, value] of iterable) {
                 this.set(key, value);

package/build/deterministic/DeterministicMap.d.ts

@@ -1,11 +1,11 @@
-import { Map } from './Map.js';
-export declare class DeterministicMap<K, V> {
+import { FastMap, PropertyExtendedKey } from './FastMap.js';
+export declare class DeterministicMap<K extends PropertyExtendedKey, 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>;
+    static fromMap<K extends PropertyExtendedKey, V>(map: FastMap<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]>;

package/build/deterministic/DeterministicMap.js

@@ -10,12 +10,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _DeterministicMap_keys;
-import { Map } from './Map.js';
+import { FastMap } from './FastMap.js';
 export class DeterministicMap {
     constructor(compareFn) {
         this.compareFn = compareFn;
         _DeterministicMap_keys.set(this, void 0);
-        this.map = new Map();
+        this.map = new FastMap();
         __classPrivateFieldSet(this, _DeterministicMap_keys, [], "f");
     }
     get size() {

package/build/deterministic/FastMap.d.ts

@@ -0,0 +1,24 @@
+export type PropertyExtendedKey = PropertyKey | bigint;
+export type FastRecord<V> = {
+    [key: string]: V;
+};
+export type IndexKey = string | number;
+export declare class FastMap<K extends PropertyExtendedKey, V> {
+    protected _keys: K[];
+    protected _values: FastRecord<V>;
+    constructor(iterable?: ReadonlyArray<readonly [K, V]> | null | FastMap<K, V>);
+    get size(): number;
+    setAll(map: FastMap<K, V>): void;
+    addAll(map: FastMap<K, V>): void;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    set(key: K, value: V): this;
+    indexOf(key: K): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    forEach(callback: (value: V, key: K, map: FastMap<K, V>) => void, thisArg?: unknown): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}

package/build/deterministic/FastMap.js

@@ -0,0 +1,88 @@
+export class FastMap {
+    constructor(iterable) {
+        this._keys = [];
+        this._values = {};
+        if (iterable instanceof FastMap) {
+            this.setAll(iterable);
+        }
+        else {
+            if (iterable) {
+                for (const [key, value] of iterable) {
+                    this.set(key, value);
+                }
+            }
+        }
+    }
+    get size() {
+        return this._keys.length;
+    }
+    setAll(map) {
+        this._keys = [...map._keys];
+        this._values = { ...map._values };
+    }
+    addAll(map) {
+        for (const [key, value] of map.entries()) {
+            this.set(key, value);
+        }
+    }
+    *keys() {
+        yield* this._keys;
+    }
+    *values() {
+        for (const key of this._keys) {
+            yield this._values[key];
+        }
+    }
+    *entries() {
+        for (const key of this._keys) {
+            yield [key, this._values[key]];
+        }
+    }
+    set(key, value) {
+        if (!this.has(key)) {
+            this._keys.push(key);
+        }
+        this._values[key] = value;
+        return this;
+    }
+    indexOf(key) {
+        if (!this.has(key)) {
+            return -1;
+        }
+        for (let i = 0; i < this._keys.length; i++) {
+            if (this._keys[i] === key) {
+                return i;
+            }
+        }
+        throw new Error('Key not found, this should not happen.');
+    }
+    get(key) {
+        return this._values[key];
+    }
+    has(key) {
+        return Object.prototype.hasOwnProperty.call(this._values, key);
+    }
+    delete(key) {
+        if (!this.has(key)) {
+            return false;
+        }
+        const index = this.indexOf(key);
+        this._keys.splice(index, 1);
+        delete this._values[key];
+        return true;
+    }
+    clear() {
+        this._keys = [];
+        this._values = {};
+    }
+    forEach(callback, thisArg) {
+        for (const key of this._keys) {
+            callback.call(thisArg, this._values[key], key, this);
+        }
+    }
+    *[Symbol.iterator]() {
+        for (const key of this._keys) {
+            yield [key, this._values[key]];
+        }
+    }
+}

package/build/opnet.d.ts

@@ -75,7 +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';
+export * from './deterministic/FastMap.js';
 export * from './deterministic/CustomMap.js';
 declare global {
     interface Window {

package/build/opnet.js

@@ -74,5 +74,5 @@ 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';
+export * from './deterministic/FastMap.js';
 export * from './deterministic/CustomMap.js';

package/package.json

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

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.7.1';
+export const version = '1.7.7';

package/src/deterministic/AddressMap.ts

@@ -1,11 +1,11 @@
 import { Address } from '../keypair/Address.js';
-import { Map } from './Map.js';
+import { FastMap } from './FastMap.js';
 
 export class AddressMap<V> {
-    private items: Map<bigint, V>;
+    private items: FastMap<bigint, V>;
 
     constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null) {
-        this.items = new Map();
+        this.items = new FastMap();
 
         if (iterable) {
             for (const [key, value] of iterable) {

package/src/deterministic/DeterministicMap.ts

@@ -1,11 +1,11 @@
-import { Map } from './Map.js';
+import { FastMap, PropertyExtendedKey } from './FastMap.js';
 
-export class DeterministicMap<K, V> {
-    private map: Map<K, V>;
+export class DeterministicMap<K extends PropertyExtendedKey, V> {
+    private map: FastMap<K, V>;
     #keys: K[];
 
     constructor(private compareFn: (a: K, b: K) => number) {
-        this.map = new Map<K, V>();
+        this.map = new FastMap<K, V>();
         this.#keys = [];
     }
 
@@ -13,8 +13,8 @@ export class DeterministicMap<K, V> {
         return this.map.size;
     }
 
-    public static fromMap<K, V>(
-        map: Map<K, V>,
+    public static fromMap<K extends PropertyExtendedKey, V>(
+        map: FastMap<K, V>,
         compareFn: (a: K, b: K) => number,
     ): DeterministicMap<K, V> {
         const deterministicMap = new DeterministicMap<K, V>(compareFn);
@@ -29,6 +29,7 @@ export class DeterministicMap<K, V> {
             // 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) {
@@ -39,6 +40,7 @@ export class DeterministicMap<K, V> {
             }
             this.#keys.splice(left, 0, key);
         }
+
         this.map.set(key, value);
     }
 
@@ -78,6 +80,7 @@ export class DeterministicMap<K, V> {
             // 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);

package/src/deterministic/FastMap.ts

@@ -0,0 +1,124 @@
+export type PropertyExtendedKey = PropertyKey | bigint;
+
+/**
+ * Like Record, but supports bigint keys (which JS auto-converts to strings).
+ * Reflects actual JavaScript behavior where obj[123n] becomes obj["123"].
+ */
+export type FastRecord<V> = {
+    [key: string]: V;
+};
+
+export type IndexKey = string | number;
+
+export class FastMap<K extends PropertyExtendedKey, V> {
+    protected _keys: K[] = [];
+    protected _values: FastRecord<V> = {};
+
+    constructor(iterable?: ReadonlyArray<readonly [K, V]> | null | FastMap<K, V>) {
+        if (iterable instanceof FastMap) {
+            this.setAll(iterable);
+        } else {
+            if (iterable) {
+                for (const [key, value] of iterable) {
+                    this.set(key, value);
+                }
+            }
+        }
+    }
+
+    public get size(): number {
+        return this._keys.length;
+    }
+
+    public setAll(map: FastMap<K, V>): void {
+        this._keys = [...map._keys];
+        this._values = { ...map._values };
+    }
+
+    public addAll(map: FastMap<K, V>): void {
+        for (const [key, value] of map.entries()) {
+            this.set(key, value);
+        }
+    }
+
+    public *keys(): IterableIterator<K> {
+        yield* this._keys;
+    }
+
+    public *values(): IterableIterator<V> {
+        for (const key of this._keys) {
+            yield this._values[key as IndexKey];
+        }
+    }
+
+    public *entries(): IterableIterator<[K, V]> {
+        for (const key of this._keys) {
+            yield [key, this._values[key as IndexKey]];
+        }
+    }
+
+    public set(key: K, value: V): this {
+        if (!this.has(key)) {
+            this._keys.push(key);
+        }
+
+        this._values[key as IndexKey] = value;
+
+        return this;
+    }
+
+    public indexOf(key: K): number {
+        if (!this.has(key)) {
+            return -1;
+        }
+
+        for (let i = 0; i < this._keys.length; i++) {
+            if (this._keys[i] === key) {
+                return i;
+            }
+        }
+
+        throw new Error('Key not found, this should not happen.');
+    }
+
+    public get(key: K): V | undefined {
+        return this._values[key as IndexKey];
+    }
+
+    public has(key: K): boolean {
+        return Object.prototype.hasOwnProperty.call(this._values, key as IndexKey);
+    }
+
+    public delete(key: K): boolean {
+        if (!this.has(key)) {
+            return false;
+        }
+
+        const index = this.indexOf(key);
+        this._keys.splice(index, 1);
+
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete this._values[key as IndexKey];
+        return true;
+    }
+
+    public clear(): void {
+        this._keys = [];
+        this._values = {};
+    }
+
+    public forEach(
+        callback: (value: V, key: K, map: FastMap<K, V>) => void,
+        thisArg?: unknown,
+    ): void {
+        for (const key of this._keys) {
+            callback.call(thisArg, this._values[key as IndexKey], key, this);
+        }
+    }
+
+    *[Symbol.iterator](): IterableIterator<[K, V]> {
+        for (const key of this._keys) {
+            yield [key, this._values[key as IndexKey]];
+        }
+    }
+}

package/src/opnet.ts

@@ -125,7 +125,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/FastMap.js';
 export * from './deterministic/CustomMap.js';
 
 declare global {

package/test/fastmap-setall.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it } from 'vitest';
+import { FastBigIntMap } from './old/FastBigIntMap.js';
+import { FastMap } from '../src';
+
+describe('setAll bug', () => {
+    describe('FastBigIntMap (original - correct behavior)', () => {
+        it('should replace all entries, not merge', () => {
+            const map1 = new FastBigIntMap([
+                [1n, 100n],
+                [2n, 200n],
+            ]);
+
+            const map2 = new FastBigIntMap([
+                [3n, 300n],
+                [4n, 400n],
+            ]);
+
+            // setAll should REPLACE, not merge
+            map2.setAll(map1);
+
+            // Should have entries from map1 only
+            expect(map2.size).toBe(2);
+            expect(map2.get(1n)).toBe(100n);
+            expect(map2.get(2n)).toBe(200n);
+
+            // Old entries should be GONE
+            expect(map2.has(3n)).toBe(false);
+            expect(map2.has(4n)).toBe(false);
+            expect(map2.get(3n)).toBeUndefined();
+            expect(map2.get(4n)).toBeUndefined();
+        });
+    });
+
+    describe('FastMap (replacement - should match original behavior)', () => {
+        it('should replace all entries, not merge', () => {
+            const map1 = new FastMap<bigint, bigint>([
+                [1n, 100n],
+                [2n, 200n],
+            ]);
+
+            const map2 = new FastMap<bigint, bigint>([
+                [3n, 300n],
+                [4n, 400n],
+            ]);
+
+            // setAll should REPLACE, not merge
+            map2.setAll(map1);
+
+            // Should have entries from map1 only
+            expect(map2.size).toBe(2);
+            expect(map2.get(1n)).toBe(100n);
+            expect(map2.get(2n)).toBe(200n);
+
+            // Old entries should be GONE
+            expect(map2.has(3n)).toBe(false);
+            expect(map2.has(4n)).toBe(false);
+            expect(map2.get(3n)).toBeUndefined();
+            expect(map2.get(4n)).toBeUndefined();
+        });
+
+        it('should not leak old keys in iteration', () => {
+            const map1 = new FastMap<bigint, bigint>([[1n, 100n]]);
+
+            const map2 = new FastMap<bigint, bigint>([
+                [2n, 200n],
+                [3n, 300n],
+            ]);
+
+            map2.setAll(map1);
+
+            const keys = [...map2.keys()];
+            const values = [...map2.values()];
+            const entries = [...map2.entries()];
+
+            expect(keys).toEqual([1n]);
+            expect(values).toEqual([100n]);
+            expect(entries).toEqual([[1n, 100n]]);
+        });
+
+        it('should handle overlapping keys correctly', () => {
+            const map1 = new FastMap<bigint, bigint>([
+                [1n, 100n],
+                [2n, 200n],
+            ]);
+
+            const map2 = new FastMap<bigint, bigint>([
+                [2n, 999n], // overlapping key
+                [3n, 300n],
+            ]);
+
+            map2.setAll(map1);
+
+            // Should have map1's values, including overwriting the overlapping key
+            expect(map2.size).toBe(2);
+            expect(map2.get(1n)).toBe(100n);
+            expect(map2.get(2n)).toBe(200n); // map1's value, not 999n
+
+            // 3n should be gone
+            expect(map2.has(3n)).toBe(false);
+        });
+    });
+
+    describe('behavior parity', () => {
+        it('FastMap.setAll should behave identically to FastBigIntMap.setAll', () => {
+            // Setup identical scenarios
+            const oldMap1 = new FastBigIntMap([
+                [1n, 10n],
+                [2n, 20n],
+            ]);
+            const oldMap2 = new FastBigIntMap([
+                [3n, 30n],
+                [4n, 40n],
+                [5n, 50n],
+            ]);
+
+            const newMap1 = new FastMap<bigint, bigint>([
+                [1n, 10n],
+                [2n, 20n],
+            ]);
+            const newMap2 = new FastMap<bigint, bigint>([
+                [3n, 30n],
+                [4n, 40n],
+                [5n, 50n],
+            ]);
+
+            // Perform setAll on both
+            oldMap2.setAll(oldMap1);
+            newMap2.setAll(newMap1);
+
+            // Compare sizes
+            expect(newMap2.size).toBe(oldMap2.size);
+
+            // Compare keys
+            expect([...newMap2.keys()]).toEqual([...oldMap2.keys()]);
+
+            // Compare values
+            expect([...newMap2.values()]).toEqual([...oldMap2.values()]);
+
+            // Compare entries
+            expect([...newMap2.entries()]).toEqual([...oldMap2.entries()]);
+        });
+    });
+});