@btc-vision/transaction 1.7.4 → 1.7.5

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

@@ -1,10 +1,9 @@
 import { Address } from '../keypair/Address.js';
 export declare class AddressMap<V> {
     private items;
-    private keyOrder;
     constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null);
     get size(): number;
-    set(key: Address, value: V): void;
+    set(key: Address, value: V): this;
     get(key: Address): V | undefined;
     has(key: Address): boolean;
     delete(key: Address): boolean;

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

@@ -0,0 +1,29 @@
+export declare class CustomMap<K, V> {
+    #private;
+    private static readonly INITIAL_CAPACITY;
+    private static readonly LOAD_FACTOR;
+    private deleted;
+    private capacity;
+    constructor();
+    private _size;
+    get size(): number;
+    set(key: K, value: V): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    indexOf(key: K): number;
+    delete(key: K): boolean;
+    clear(): void;
+    entries(): MapIterator<[K, V]>;
+    keys(): MapIterator<K>;
+    values(): MapIterator<V>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
+    private hashBigInt;
+    private hash;
+    private hashBuffer;
+    private equals;
+    private buffersEqual;
+    private getBytes;
+    private findIndex;
+    private findInsertIndex;
+    private resize;
+}

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

@@ -1,6 +1,6 @@
 export declare class Map<K, V> {
     protected _keys: K[];
-    protected _values: V[];
+    protected _values: Record<string, V>;
     get size(): number;
     keys(): IterableIterator<K>;
     values(): IterableIterator<V>;
@@ -12,4 +12,5 @@ export declare class Map<K, V> {
     delete(key: K): boolean;
     clear(): void;
     [Symbol.iterator](): IterableIterator<[K, V]>;
+    private keyToString;
 }

package/browser/src/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/deterministic/AddressMap.d.ts

@@ -1,10 +1,9 @@
 import { Address } from '../keypair/Address.js';
 export declare class AddressMap<V> {
     private items;
-    private keyOrder;
     constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null);
     get size(): number;
-    set(key: Address, value: V): void;
+    set(key: Address, value: V): this;
     get(key: Address): V | undefined;
     has(key: Address): boolean;
     delete(key: Address): boolean;

package/build/deterministic/AddressMap.js

@@ -1,8 +1,8 @@
+import { Address } from '../keypair/Address.js';
 import { Map } from './Map.js';
 export class AddressMap {
     constructor(iterable) {
         this.items = new Map();
-        this.keyOrder = [];
         if (iterable) {
             for (const [key, value] of iterable) {
                 this.set(key, value);
@@ -10,14 +10,12 @@ export class AddressMap {
         }
     }
     get size() {
-        return this.keyOrder.length;
+        return this.items.size;
     }
     set(key, value) {
         const keyBigInt = key.toBigInt();
-        if (!this.items.has(keyBigInt)) {
-            this.keyOrder.push(key);
-        }
         this.items.set(keyBigInt, value);
+        return this;
     }
     get(key) {
         return this.items.get(key.toBigInt());
@@ -27,47 +25,36 @@ export class AddressMap {
     }
     delete(key) {
         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);
     }
     clear() {
         this.items.clear();
-        this.keyOrder = [];
     }
     indexOf(address) {
-        const addressBigInt = address.toBigInt();
-        for (let i = 0; i < this.keyOrder.length; i++) {
-            if (this.keyOrder[i].toBigInt() === addressBigInt) {
-                return i;
-            }
-        }
-        return -1;
+        return this.items.indexOf(address.toBigInt());
     }
     *entries() {
-        for (const key of this.keyOrder) {
-            yield [key, this.items.get(key.toBigInt())];
+        for (const [keyBigInt, value] of this.items.entries()) {
+            yield [Address.fromBigInt(keyBigInt), value];
         }
     }
     *keys() {
-        yield* this.keyOrder;
+        for (const keyBigInt of this.items.keys()) {
+            yield Address.fromBigInt(keyBigInt);
+        }
     }
     *values() {
-        for (const key of this.keyOrder) {
-            yield this.items.get(key.toBigInt());
+        for (const value of this.items.values()) {
+            yield value;
         }
     }
     forEach(callback, thisArg) {
-        for (const key of this.keyOrder) {
-            callback.call(thisArg, this.items.get(key.toBigInt()), key, this);
+        for (const [keyBigInt, value] of this.items.entries()) {
+            const key = Address.fromBigInt(keyBigInt);
+            callback.call(thisArg, value, key, this);
         }
     }
     *[Symbol.iterator]() {
-        for (let i = 0; i < this.keyOrder.length; i++) {
-            const key = this.keyOrder[i];
-            yield [key, this.items.get(key.toBigInt())];
-        }
+        yield* this.entries();
     }
 }

package/build/deterministic/CustomMap.d.ts

@@ -0,0 +1,29 @@
+export declare class CustomMap<K, V> {
+    #private;
+    private static readonly INITIAL_CAPACITY;
+    private static readonly LOAD_FACTOR;
+    private deleted;
+    private capacity;
+    constructor();
+    private _size;
+    get size(): number;
+    set(key: K, value: V): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    indexOf(key: K): number;
+    delete(key: K): boolean;
+    clear(): void;
+    entries(): MapIterator<[K, V]>;
+    keys(): MapIterator<K>;
+    values(): MapIterator<V>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
+    private hashBigInt;
+    private hash;
+    private hashBuffer;
+    private equals;
+    private buffersEqual;
+    private getBytes;
+    private findIndex;
+    private findInsertIndex;
+    private resize;
+}

package/build/deterministic/CustomMap.js

@@ -0,0 +1,253 @@
+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 _CustomMap_keys, _CustomMap_values;
+export class CustomMap {
+    constructor() {
+        _CustomMap_keys.set(this, void 0);
+        _CustomMap_values.set(this, void 0);
+        this._size = 0;
+        this.capacity = CustomMap.INITIAL_CAPACITY;
+        __classPrivateFieldSet(this, _CustomMap_keys, new Array(this.capacity), "f");
+        __classPrivateFieldSet(this, _CustomMap_values, new Array(this.capacity), "f");
+        this.deleted = new Array(this.capacity).fill(false);
+    }
+    get size() {
+        return this._size;
+    }
+    set(key, value) {
+        let exist = true;
+        const index = this.findInsertIndex(key);
+        if (__classPrivateFieldGet(this, _CustomMap_keys, "f")[index] === undefined || this.deleted[index]) {
+            this._size++;
+            exist = false;
+        }
+        __classPrivateFieldGet(this, _CustomMap_keys, "f")[index] = key;
+        __classPrivateFieldGet(this, _CustomMap_values, "f")[index] = value;
+        this.deleted[index] = false;
+        if (this._size > this.capacity * CustomMap.LOAD_FACTOR) {
+            this.resize();
+        }
+        return exist;
+    }
+    get(key) {
+        const index = this.findIndex(key);
+        return index === -1 ? undefined : __classPrivateFieldGet(this, _CustomMap_values, "f")[index];
+    }
+    has(key) {
+        return this.findIndex(key) !== -1;
+    }
+    indexOf(key) {
+        return this.findIndex(key);
+    }
+    delete(key) {
+        const index = this.findIndex(key);
+        if (index === -1) {
+            return false;
+        }
+        __classPrivateFieldGet(this, _CustomMap_keys, "f")[index] = undefined;
+        __classPrivateFieldGet(this, _CustomMap_values, "f")[index] = undefined;
+        this.deleted[index] = true;
+        this._size--;
+        return true;
+    }
+    clear() {
+        __classPrivateFieldSet(this, _CustomMap_keys, new Array(this.capacity), "f");
+        __classPrivateFieldSet(this, _CustomMap_values, new Array(this.capacity), "f");
+        this.deleted = new Array(this.capacity).fill(false);
+        this._size = 0;
+    }
+    *entries() {
+        for (let i = 0; i < this.capacity; i++) {
+            if (__classPrivateFieldGet(this, _CustomMap_keys, "f")[i] !== undefined && !this.deleted[i]) {
+                yield [__classPrivateFieldGet(this, _CustomMap_keys, "f")[i], __classPrivateFieldGet(this, _CustomMap_values, "f")[i]];
+            }
+        }
+    }
+    *keys() {
+        for (let i = 0; i < this.capacity; i++) {
+            if (__classPrivateFieldGet(this, _CustomMap_keys, "f")[i] !== undefined && !this.deleted[i]) {
+                yield __classPrivateFieldGet(this, _CustomMap_keys, "f")[i];
+            }
+        }
+    }
+    *values() {
+        for (let i = 0; i < this.capacity; i++) {
+            if (__classPrivateFieldGet(this, _CustomMap_keys, "f")[i] !== undefined && !this.deleted[i]) {
+                yield __classPrivateFieldGet(this, _CustomMap_values, "f")[i];
+            }
+        }
+    }
+    *[(_CustomMap_keys = new WeakMap(), _CustomMap_values = new WeakMap(), Symbol.iterator)]() {
+        yield* this.entries();
+    }
+    hashBigInt(key) {
+        if (key >= -2147483648n && key <= 2147483647n) {
+            return Number(key) | 0;
+        }
+        let hash = 2166136261;
+        let n = key < 0n ? -key : key;
+        while (n > 0n) {
+            const chunk = Number(n & 0xffffffffn);
+            hash ^= chunk;
+            hash = Math.imul(hash, 16777619);
+            n = n >> 32n;
+        }
+        if (key < 0n) {
+            hash ^= 0x80000000;
+            hash = Math.imul(hash, 16777619);
+        }
+        return Math.abs(hash);
+    }
+    hash(key) {
+        let hash = 0;
+        switch (typeof key) {
+            case 'number':
+                if (key !== key)
+                    return 0x7ff8000000000000;
+                if (!isFinite(key))
+                    return key > 0 ? 0x7ff0000000000000 : 0xfff0000000000000;
+                hash = key | 0;
+                break;
+            case 'string':
+                hash = 2166136261;
+                for (let i = 0; i < key.length; i++) {
+                    hash ^= key.charCodeAt(i);
+                    hash = Math.imul(hash, 16777619);
+                }
+                break;
+            case 'boolean':
+                hash = key ? 1231 : 1237;
+                break;
+            case 'symbol': {
+                const desc = key.description || '';
+                hash = this.hash(desc);
+                break;
+            }
+            case 'bigint':
+                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) {
+                    hash = this.hashBuffer(key);
+                }
+                else if (Array.isArray(key)) {
+                    hash = 1;
+                    for (const item of key) {
+                        hash = Math.imul(hash, 31) + this.hash(item);
+                    }
+                }
+                else {
+                    throw new Error('Raw object not supported.');
+                }
+                break;
+            case 'function':
+                hash = this.hash(key.toString());
+                break;
+        }
+        return Math.abs(hash) % this.capacity;
+    }
+    hashBuffer(buffer) {
+        let bytes;
+        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;
+        }
+        let hash = 2166136261;
+        for (let i = 0; i < Math.min(bytes.length, 100); i++) {
+            hash ^= bytes[i];
+            hash = Math.imul(hash, 16777619);
+        }
+        return hash;
+    }
+    equals(a, b) {
+        if (a === b)
+            return true;
+        if (typeof a === 'number' && typeof b === 'number' && a !== a && b !== b) {
+            return true;
+        }
+        if ((ArrayBuffer.isView(a) || a instanceof ArrayBuffer) &&
+            (ArrayBuffer.isView(b) || b instanceof ArrayBuffer)) {
+            return this.buffersEqual(a, b);
+        }
+        return false;
+    }
+    buffersEqual(a, b) {
+        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;
+    }
+    getBytes(buffer) {
+        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);
+    }
+    findIndex(key) {
+        let index = this.hash(key);
+        while (__classPrivateFieldGet(this, _CustomMap_keys, "f")[index] !== undefined || this.deleted[index]) {
+            if (__classPrivateFieldGet(this, _CustomMap_keys, "f")[index] !== undefined && this.equals(__classPrivateFieldGet(this, _CustomMap_keys, "f")[index], key)) {
+                return index;
+            }
+            index = (index + 1) % this.capacity;
+        }
+        return -1;
+    }
+    findInsertIndex(key) {
+        let index = this.hash(key);
+        while (__classPrivateFieldGet(this, _CustomMap_keys, "f")[index] !== undefined && !this.deleted[index]) {
+            if (this.equals(__classPrivateFieldGet(this, _CustomMap_keys, "f")[index], key)) {
+                return index;
+            }
+            index = (index + 1) % this.capacity;
+        }
+        return index;
+    }
+    resize() {
+        const oldKeys = __classPrivateFieldGet(this, _CustomMap_keys, "f");
+        const oldValues = __classPrivateFieldGet(this, _CustomMap_values, "f");
+        this.capacity *= 2;
+        __classPrivateFieldSet(this, _CustomMap_keys, new Array(this.capacity), "f");
+        __classPrivateFieldSet(this, _CustomMap_values, new Array(this.capacity), "f");
+        this.deleted = new Array(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], oldValues[i]);
+            }
+        }
+    }
+}
+CustomMap.INITIAL_CAPACITY = 16;
+CustomMap.LOAD_FACTOR = 0.75;

package/build/deterministic/Map.d.ts

@@ -1,6 +1,6 @@
 export declare class Map<K, V> {
     protected _keys: K[];
-    protected _values: V[];
+    protected _values: Record<string, V>;
     get size(): number;
     keys(): IterableIterator<K>;
     values(): IterableIterator<V>;
@@ -12,4 +12,5 @@ export declare class Map<K, V> {
     delete(key: K): boolean;
     clear(): void;
     [Symbol.iterator](): IterableIterator<[K, V]>;
+    private keyToString;
 }

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.4",
+    "version": "1.7.5",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {