@btc-vision/transaction 1.8.0-alpha.1 → 1.8.0-alpha.2

package/build/utils/lengths.js

@@ -1,4 +1,6 @@
 export const ADDRESS_BYTE_LENGTH = 32;
+export const EXTENDED_ADDRESS_BYTE_LENGTH = 64;
+export const SCHNORR_SIGNATURE_BYTE_LENGTH = 64;
 export const SELECTOR_BYTE_LENGTH = 4;
 export const U256_BYTE_LENGTH = 32;
 export const U128_BYTE_LENGTH = 16;
@@ -9,7 +11,7 @@ export const U8_BYTE_LENGTH = 1;
 export const I256_BYTE_LENGTH = 32;
 export const I128_BYTE_LENGTH = 16;
 export const I64_BYTE_LENGTH = 8;
-export const number_BYTE_LENGTH = 4;
+export const I32_BYTE_LENGTH = 4;
 export const I16_BYTE_LENGTH = 2;
 export const I8_BYTE_LENGTH = 1;
 export const BOOLEAN_BYTE_LENGTH = 1;

package/build/utils/types.d.ts

@@ -4,7 +4,10 @@ export type BufferLike = Uint8Array | Buffer;
 export type MemorySlotData<T> = T;
 export type PointerStorage = DeterministicMap<MemorySlotPointer, MemorySlotData<bigint>>;
 export type BlockchainStorage = DeterministicMap<string, PointerStorage>;
+export type i8 = number;
+export type i16 = number;
 export type i32 = number;
+export type i64 = bigint;
 export type u8 = number;
 export type u16 = number;
 export type u32 = number;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.8.0-alpha.1",
+    "version": "1.8.0-alpha.2",
     "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.31';
+export const version = '1.8.0-alpha.2';

package/src/abi/ABICoder.ts

@@ -4,21 +4,40 @@ import { BinaryReader } from '../buffer/BinaryReader.js';
 import { BufferHelper } from '../utils/BufferHelper.js';
 
 export enum ABIDataTypes {
+    // Unsigned integers
     UINT8 = 'UINT8',
     UINT16 = 'UINT16',
     UINT32 = 'UINT32',
     UINT64 = 'UINT64',
     UINT128 = 'UINT128',
     UINT256 = 'UINT256',
+
+    // Signed integers
+    INT8 = 'INT8',
+    INT16 = 'INT16',
+    INT32 = 'INT32',
+    INT64 = 'INT64',
     INT128 = 'INT128',
+
+    // Basic types
     BOOL = 'BOOL',
     ADDRESS = 'ADDRESS',
+    EXTENDED_ADDRESS = 'EXTENDED_ADDRESS',
     STRING = 'STRING',
     BYTES4 = 'BYTES4',
     BYTES32 = 'BYTES32',
     BYTES = 'BYTES',
+
+    // Tuples/Maps
     ADDRESS_UINT256_TUPLE = 'ADDRESS_UINT256_TUPLE',
+    EXTENDED_ADDRESS_UINT256_TUPLE = 'EXTENDED_ADDRESS_UINT256_TUPLE',
+
+    // Signatures
+    SCHNORR_SIGNATURE = 'SCHNORR_SIGNATURE',
+
+    // Arrays
     ARRAY_OF_ADDRESSES = 'ARRAY_OF_ADDRESSES',
+    ARRAY_OF_EXTENDED_ADDRESSES = 'ARRAY_OF_EXTENDED_ADDRESSES',
     ARRAY_OF_UINT256 = 'ARRAY_OF_UINT256',
     ARRAY_OF_UINT128 = 'ARRAY_OF_UINT128',
     ARRAY_OF_UINT64 = 'ARRAY_OF_UINT64',
@@ -68,12 +87,33 @@ export class ABICoder {
                 case ABIDataTypes.UINT256:
                     result.push(byteReader.readU256());
                     break;
+                case ABIDataTypes.INT8:
+                    result.push(byteReader.readI8());
+                    break;
+                case ABIDataTypes.INT16:
+                    result.push(byteReader.readI16());
+                    break;
+                case ABIDataTypes.INT32:
+                    result.push(byteReader.readI32());
+                    break;
+                case ABIDataTypes.INT64:
+                    result.push(byteReader.readI64());
+                    break;
                 case ABIDataTypes.INT128:
                     result.push(byteReader.readI128());
                     break;
+                case ABIDataTypes.EXTENDED_ADDRESS:
+                    result.push(byteReader.readExtendedAddress());
+                    break;
                 case ABIDataTypes.ADDRESS_UINT256_TUPLE:
                     result.push(byteReader.readAddressValueTuple());
                     break;
+                case ABIDataTypes.EXTENDED_ADDRESS_UINT256_TUPLE:
+                    result.push(byteReader.readExtendedAddressMapU256());
+                    break;
+                case ABIDataTypes.SCHNORR_SIGNATURE:
+                    result.push(byteReader.readSchnorrSignature());
+                    break;
                 case ABIDataTypes.BYTES:
                     result.push(byteReader.readBytesWithLength());
                     break;
@@ -83,6 +123,9 @@ export class ABICoder {
                 case ABIDataTypes.ARRAY_OF_ADDRESSES:
                     result.push(byteReader.readAddressArray());
                     break;
+                case ABIDataTypes.ARRAY_OF_EXTENDED_ADDRESSES:
+                    result.push(byteReader.readExtendedAddressArray());
+                    break;
                 case ABIDataTypes.ARRAY_OF_UINT256:
                     result.push(byteReader.readU256Array());
                     break;

package/src/buffer/BinaryReader.ts

@@ -1,8 +1,15 @@
 import { AddressMap } from '../deterministic/AddressMap.js';
+import { ExtendedAddressMap } from '../deterministic/ExtendedAddressMap.js';
 import { Address } from '../keypair/Address.js';
 import {
     ADDRESS_BYTE_LENGTH,
+    EXTENDED_ADDRESS_BYTE_LENGTH,
     I128_BYTE_LENGTH,
+    I16_BYTE_LENGTH,
+    I32_BYTE_LENGTH,
+    I64_BYTE_LENGTH,
+    I8_BYTE_LENGTH,
+    SCHNORR_SIGNATURE_BYTE_LENGTH,
     U128_BYTE_LENGTH,
     U16_BYTE_LENGTH,
     U256_BYTE_LENGTH,
@@ -10,7 +17,20 @@ import {
     U64_BYTE_LENGTH,
     U8_BYTE_LENGTH,
 } from '../utils/lengths.js';
-import { BufferLike, Selector, u16, u32, u8 } from '../utils/types.js';
+import { BufferLike, i16, i32, i64, i8, Selector, u16, u32, u8 } from '../utils/types.js';
+
+/**
+ * Represents a Schnorr signature paired with the signer's Address.
+ * This class bundles a 64-byte Schnorr signature with its associated
+ * full Address (both MLDSA and tweaked keys), providing a complete signed data structure
+ * for Bitcoin Taproot-compatible signatures.
+ */
+export interface SchnorrSignature {
+    /** The signer's Address containing both MLDSA and tweaked public keys */
+    readonly address: Address;
+    /** The 64-byte Schnorr signature */
+    readonly signature: Uint8Array;
+}
 
 export class BinaryReader {
     private buffer: DataView;
@@ -42,6 +62,10 @@ export class BinaryReader {
         this.currentOffset = 0;
     }
 
+    public get byteLength(): number {
+        return this.buffer.byteLength;
+    }
+
     public length(): number {
         return this.buffer.byteLength;
     }
@@ -50,6 +74,53 @@ export class BinaryReader {
         return this.buffer.byteLength - this.currentOffset;
     }
 
+    // ------------------- Signed Integer Readers ------------------- //
+
+    /**
+     * Reads a single signed byte (i8).
+     */
+    public readI8(): i8 {
+        this.verifyEnd(this.currentOffset + I8_BYTE_LENGTH);
+        const value = this.buffer.getInt8(this.currentOffset);
+        this.currentOffset += I8_BYTE_LENGTH;
+        return value;
+    }
+
+    /**
+     * Reads a signed 16-bit integer. By default, big-endian.
+     * @param be - Endianness; true means big-endian (the default).
+     */
+    public readI16(be: boolean = true): i16 {
+        this.verifyEnd(this.currentOffset + I16_BYTE_LENGTH);
+        const value = this.buffer.getInt16(this.currentOffset, !be);
+        this.currentOffset += I16_BYTE_LENGTH;
+        return value;
+    }
+
+    /**
+     * Reads a signed 32-bit integer. By default, big-endian.
+     * @param be - Endianness; true means big-endian (the default).
+     */
+    public readI32(be: boolean = true): i32 {
+        this.verifyEnd(this.currentOffset + I32_BYTE_LENGTH);
+        const value = this.buffer.getInt32(this.currentOffset, !be);
+        this.currentOffset += I32_BYTE_LENGTH;
+        return value;
+    }
+
+    /**
+     * Reads a signed 64-bit integer. By default, big-endian.
+     * @param be - Endianness; true means big-endian (the default).
+     */
+    public readI64(be: boolean = true): i64 {
+        this.verifyEnd(this.currentOffset + I64_BYTE_LENGTH);
+        const value = this.buffer.getBigInt64(this.currentOffset, !be);
+        this.currentOffset += I64_BYTE_LENGTH;
+        return value;
+    }
+
+    // ------------------- Unsigned Integer Readers ------------------- //
+
     /**
      * Reads a single unsigned byte (u8).
      */
@@ -197,13 +268,62 @@ export class BinaryReader {
     }
 
     /**
-     * Reads an address.
+     * Reads an address (32 bytes MLDSA key hash only).
      */
     public readAddress(): Address {
         const bytes: u8[] = Array.from(this.readBytes(ADDRESS_BYTE_LENGTH));
         return new Address(bytes);
     }
 
+    /**
+     * Reads the tweaked public key portion (32 bytes) and returns it as a raw Uint8Array.
+     * Use this when you only need the tweaked key without the full Address object.
+     */
+    public readTweakedPublicKey(): Uint8Array {
+        this.verifyEnd(this.currentOffset + ADDRESS_BYTE_LENGTH);
+        return this.readBytes(ADDRESS_BYTE_LENGTH);
+    }
+
+    /**
+     * Reads a full address with both MLDSA key hash and tweaked public key (64 bytes total).
+     * Format: [32 bytes tweakedPublicKey][32 bytes MLDSA key hash]
+     *
+     * This is the equivalent of btc-runtime's readExtendedAddress().
+     *
+     * @returns An Address instance with both keys set
+     */
+    public readExtendedAddress(): Address {
+        this.verifyEnd(this.currentOffset + EXTENDED_ADDRESS_BYTE_LENGTH);
+
+        // Read tweaked public key first (32 bytes)
+        const tweakedPublicKey: u8[] = Array.from(this.readBytes(ADDRESS_BYTE_LENGTH));
+
+        // Read MLDSA key hash (32 bytes)
+        const mldsaKeyHash: u8[] = Array.from(this.readBytes(ADDRESS_BYTE_LENGTH));
+
+        return new Address(mldsaKeyHash, tweakedPublicKey);
+    }
+
+    /**
+     * Reads a Schnorr signature with its associated full Address.
+     * Format: [64 bytes full Address][64 bytes signature]
+     *
+     * Used for deserializing signed data where both the signer's address
+     * and their Schnorr signature are stored together.
+     *
+     * @returns A SchnorrSignature containing the address and signature
+     */
+    public readSchnorrSignature(): SchnorrSignature {
+        this.verifyEnd(
+            this.currentOffset + EXTENDED_ADDRESS_BYTE_LENGTH + SCHNORR_SIGNATURE_BYTE_LENGTH,
+        );
+
+        const address = this.readExtendedAddress();
+        const signature = this.readBytes(SCHNORR_SIGNATURE_BYTE_LENGTH);
+
+        return { address, signature };
+    }
+
     /**
      * Reads bytes written as [u32 length][bytes].
      * @param maxLength if > 0, enforces an upper bound
@@ -329,6 +449,42 @@ export class BinaryReader {
         return result;
     }
 
+    /**
+     * Reads an array of full addresses (64 bytes each).
+     * Format: [u16 length][FullAddress 0][FullAddress 1]...
+     */
+    public readExtendedAddressArray(be: boolean = true): Address[] {
+        const length = this.readU16(be);
+        const result: Address[] = new Array<Address>(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readExtendedAddress();
+        }
+        return result;
+    }
+
+    /**
+     * Reads a map of full Address -> u256 using the tweaked key for map lookup.
+     * Format: [u16 length][FullAddress key][u256 value]...
+     *
+     * This is the equivalent of btc-runtime's readExtendedAddressMapU256().
+     */
+    public readExtendedAddressMapU256(be: boolean = true): ExtendedAddressMap<bigint> {
+        const length = this.readU16(be);
+        const result = new ExtendedAddressMap<bigint>();
+
+        for (let i = 0; i < length; i++) {
+            const address = this.readExtendedAddress();
+            const value = this.readU256(be);
+
+            if (result.has(address)) {
+                throw new Error('Duplicate tweaked address found in map');
+            }
+            result.set(address, value);
+        }
+
+        return result;
+    }
+
     // --------------------------------------------------- //
 
     public getOffset(): u16 {

package/src/buffer/BinaryWriter.ts

@@ -1,9 +1,16 @@
 import { AddressMap } from '../deterministic/AddressMap.js';
+import { ExtendedAddressMap } from '../deterministic/ExtendedAddressMap.js';
 import { Address } from '../keypair/Address.js';
 import { BufferHelper } from '../utils/BufferHelper.js';
 import {
     ADDRESS_BYTE_LENGTH,
+    EXTENDED_ADDRESS_BYTE_LENGTH,
     I128_BYTE_LENGTH,
+    I16_BYTE_LENGTH,
+    I32_BYTE_LENGTH,
+    I64_BYTE_LENGTH,
+    I8_BYTE_LENGTH,
+    SCHNORR_SIGNATURE_BYTE_LENGTH,
     U128_BYTE_LENGTH,
     U16_BYTE_LENGTH,
     U256_BYTE_LENGTH,
@@ -11,7 +18,7 @@ import {
     U64_BYTE_LENGTH,
     U8_BYTE_LENGTH,
 } from '../utils/lengths.js';
-import { Selector, u16, u32, u64, u8 } from '../utils/types.js';
+import { i16, i32, i64, i8, Selector, u16, u32, u64, u8 } from '../utils/types.js';
 import { BinaryReader } from './BinaryReader.js';
 
 export class BinaryWriter {
@@ -64,6 +71,56 @@ export class BinaryWriter {
         this.currentOffset += 8;
     }
 
+    // ------------------- Signed Integer Writers ------------------- //
+
+    /**
+     * Writes a signed 8-bit integer.
+     */
+    public writeI8(value: i8): void {
+        if (value < -128 || value > 127) throw new Error('i8 value is out of range.');
+
+        this.allocSafe(I8_BYTE_LENGTH);
+        this.buffer.setInt8(this.currentOffset, value);
+        this.currentOffset += I8_BYTE_LENGTH;
+    }
+
+    /**
+     * Writes a signed 16-bit integer. By default big-endian (be = true).
+     */
+    public writeI16(value: i16, be: boolean = true): void {
+        if (value < -32768 || value > 32767) throw new Error('i16 value is out of range.');
+
+        this.allocSafe(I16_BYTE_LENGTH);
+        this.buffer.setInt16(this.currentOffset, value, !be);
+        this.currentOffset += I16_BYTE_LENGTH;
+    }
+
+    /**
+     * Writes a signed 32-bit integer. By default big-endian (be = true).
+     */
+    public writeI32(value: i32, be: boolean = true): void {
+        if (value < -2147483648 || value > 2147483647) throw new Error('i32 value is out of range.');
+
+        this.allocSafe(I32_BYTE_LENGTH);
+        this.buffer.setInt32(this.currentOffset, value, !be);
+        this.currentOffset += I32_BYTE_LENGTH;
+    }
+
+    /**
+     * Writes a signed 64-bit integer. By default big-endian (be = true).
+     */
+    public writeI64(value: i64, be: boolean = true): void {
+        if (value < -9223372036854775808n || value > 9223372036854775807n) {
+            throw new Error('i64 value is out of range.');
+        }
+
+        this.allocSafe(I64_BYTE_LENGTH);
+        this.buffer.setBigInt64(this.currentOffset, value, !be);
+        this.currentOffset += I64_BYTE_LENGTH;
+    }
+
+    // ---------------------------------------------------------------- //
+
     public writeSelector(value: Selector): void {
         this.writeU32(value, true);
     }
@@ -173,12 +230,65 @@ export class BinaryWriter {
         this.writeBytes(bytes);
     }
 
+    /**
+     * Writes an address (32 bytes MLDSA key hash only).
+     */
     public writeAddress(value: Address): void {
         this.verifyAddress(value);
 
         this.writeBytes(value);
     }
 
+    /**
+     * Writes the tweaked public key from an Address (32 bytes).
+     * @param value - The Address containing the tweaked public key
+     */
+    public writeTweakedPublicKey(value: Address): void {
+        const tweakedKey = value.tweakedPublicKeyToBuffer();
+        this.allocSafe(ADDRESS_BYTE_LENGTH);
+        this.writeBytes(tweakedKey);
+    }
+
+    /**
+     * Writes a full address with both tweaked public key and MLDSA key hash (64 bytes total).
+     * Format: [32 bytes tweakedPublicKey][32 bytes MLDSA key hash]
+     *
+     * This is the equivalent of btc-runtime's writeExtendedAddress().
+     *
+     * @param value - The Address containing both keys
+     */
+    public writeExtendedAddress(value: Address): void {
+        this.allocSafe(EXTENDED_ADDRESS_BYTE_LENGTH);
+
+        // Write tweaked public key first (32 bytes)
+        this.writeTweakedPublicKey(value);
+
+        // Write MLDSA key hash (32 bytes)
+        this.writeBytes(value);
+    }
+
+    /**
+     * Writes a Schnorr signature with its associated full Address.
+     * Format: [64 bytes full Address][64 bytes signature]
+     *
+     * Used for serializing signed data where both the signer's address
+     * and their Schnorr signature need to be stored together.
+     *
+     * @param address - The signer's Address (with both MLDSA and tweaked keys)
+     * @param signature - The 64-byte Schnorr signature
+     * @throws {Error} If signature is not exactly 64 bytes
+     */
+    public writeSchnorrSignature(address: Address, signature: Uint8Array): void {
+        if (signature.length !== SCHNORR_SIGNATURE_BYTE_LENGTH) {
+            throw new Error(
+                `Invalid Schnorr signature length: expected ${SCHNORR_SIGNATURE_BYTE_LENGTH}, got ${signature.length}`,
+            );
+        }
+        this.allocSafe(EXTENDED_ADDRESS_BYTE_LENGTH + SCHNORR_SIGNATURE_BYTE_LENGTH);
+        this.writeExtendedAddress(address);
+        this.writeBytes(signature);
+    }
+
     public getBuffer(clear: boolean = true): Uint8Array {
         const buf = new Uint8Array(this.buffer.byteLength);
         for (let i: u32 = 0; i < this.buffer.byteLength; i++) {
@@ -235,6 +345,23 @@ export class BinaryWriter {
         }
     }
 
+    /**
+     * Writes a map of full Address -> u256 using the tweaked key for map lookup.
+     * Format: [u16 length][FullAddress key][u256 value]...
+     *
+     * This is the equivalent of btc-runtime's writeExtendedAddressMapU256().
+     */
+    public writeExtendedAddressMapU256(map: ExtendedAddressMap<bigint>, be: boolean = true): void {
+        if (map.size > 65535) throw new Error('Map size is too large');
+
+        this.writeU16(map.size, be);
+
+        for (const [key, value] of map.entries()) {
+            this.writeExtendedAddress(key);
+            this.writeU256(value, be);
+        }
+    }
+
     public writeBytesWithLength(value: Uint8Array): void {
         this.writeU32(value.length);
         this.writeBytes(value);
@@ -262,6 +389,21 @@ export class BinaryWriter {
         }
     }
 
+    /**
+     * Writes an array of full addresses (64 bytes each).
+     * Format: [u16 length][FullAddress 0][FullAddress 1]...
+     */
+    public writeExtendedAddressArray(value: Address[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.allocSafe(U16_BYTE_LENGTH + value.length * EXTENDED_ADDRESS_BYTE_LENGTH);
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeExtendedAddress(value[i]);
+        }
+    }
+
     public writeU32Array(value: u32[], be: boolean = true): void {
         if (value.length > 65535) throw new Error('Array size is too large');
 

package/src/deterministic/ExtendedAddressMap.ts

@@ -1,11 +1,19 @@
 import { Address } from '../keypair/Address.js';
 import { FastMap } from './FastMap.js';
 
+/**
+ * A map implementation using Address with both MLDSA and tweaked keys.
+ * Uses the tweaked public key for lookup/indexing, but stores the full Address.
+ */
 export class ExtendedAddressMap<V> {
-    private items: FastMap<bigint, V>;
+    // Store tweaked bigint -> index mapping for fast lookup
+    private indexMap: FastMap<bigint, number>;
+    // Store actual addresses and values
+    private _keys: Address[] = [];
+    private _values: V[] = [];
 
     constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null) {
-        this.items = new FastMap();
+        this.indexMap = new FastMap();
 
         if (iterable) {
             for (const [key, value] of iterable) {
@@ -15,54 +23,86 @@ export class ExtendedAddressMap<V> {
     }
 
     public get size(): number {
-        return this.items.size;
+        return this._keys.length;
     }
 
     public set(key: Address, value: V): this {
         const keyBigInt = key.tweakedToBigInt();
-        this.items.set(keyBigInt, value);
+        const existingIndex = this.indexMap.get(keyBigInt);
+
+        if (existingIndex !== undefined) {
+            // Update existing entry
+            this._values[existingIndex] = value;
+        } else {
+            // Add new entry
+            const newIndex = this._keys.length;
+            this._keys.push(key);
+            this._values.push(value);
+            this.indexMap.set(keyBigInt, newIndex);
+        }
 
         return this;
     }
 
     public get(key: Address): V | undefined {
-        return this.items.get(key.tweakedToBigInt());
+        const keyBigInt = key.tweakedToBigInt();
+        const index = this.indexMap.get(keyBigInt);
+        if (index === undefined) {
+            return undefined;
+        }
+        return this._values[index];
     }
 
     public has(key: Address): boolean {
-        return this.items.has(key.tweakedToBigInt());
+        return this.indexMap.has(key.tweakedToBigInt());
     }
 
     public delete(key: Address): boolean {
         const keyBigInt = key.tweakedToBigInt();
-        return this.items.delete(keyBigInt);
+        const index = this.indexMap.get(keyBigInt);
+
+        if (index === undefined) {
+            return false;
+        }
+
+        // Remove from arrays
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+
+        // Rebuild index map (indices shifted after splice)
+        this.indexMap.clear();
+        for (let i = 0; i < this._keys.length; i++) {
+            this.indexMap.set(this._keys[i].tweakedToBigInt(), i);
+        }
+
+        return true;
     }
 
     public clear(): void {
-        this.items.clear();
+        this.indexMap.clear();
+        this._keys = [];
+        this._values = [];
     }
 
     public indexOf(address: Address): number {
-        return this.items.indexOf(address.tweakedToBigInt());
+        const index = this.indexMap.get(address.tweakedToBigInt());
+        return index !== undefined ? index : -1;
     }
 
-    /**
-     * WARNING, THIS RETURN NEW COPY OF THE KEYS
-     */
     *entries(): IterableIterator<[Address, V]> {
-        for (const [keyBigInt, value] of this.items.entries()) {
-            yield [Address.fromBigInt(keyBigInt), value];
+        for (let i = 0; i < this._keys.length; i++) {
+            yield [this._keys[i], this._values[i]];
         }
     }
 
     *keys(): IterableIterator<Address> {
-        for (const keyBigInt of this.items.keys()) {
-            yield Address.fromBigInt(keyBigInt);
+        for (const key of this._keys) {
+            yield key;
         }
     }
 
     *values(): IterableIterator<V> {
-        for (const value of this.items.values()) {
+        for (const value of this._values) {
             yield value;
         }
     }
@@ -71,9 +111,8 @@ export class ExtendedAddressMap<V> {
         callback: (value: V, key: Address, map: ExtendedAddressMap<V>) => void,
         thisArg?: unknown,
     ): void {
-        for (const [keyBigInt, value] of this.items.entries()) {
-            const key = Address.fromBigInt(0n, keyBigInt);
-            callback.call(thisArg, value, key, this);
+        for (let i = 0; i < this._keys.length; i++) {
+            callback.call(thisArg, this._values[i], this._keys[i], this);
         }
     }