@btc-vision/btc-runtime 1.3.15 → 1.3.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.3.15",
+    "version": "1.3.17",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {

package/runtime/buffer/BytesReader.ts

@@ -1,10 +1,22 @@
-import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
-import { Selector } from '../math/abi';
 import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
-import { Revert } from '../types/Revert';
 import { TransactionInput, TransactionOutput } from '../env/classes/UTXO';
-import { i256 } from '../math/i256';
 import { AddressMap } from '../generic/AddressMap';
+import { Selector } from '../math/abi';
+import { i256 } from '../math/i256';
+import { Address } from '../types/Address';
+import { Revert } from '../types/Revert';
+import {
+    ADDRESS_BYTE_LENGTH,
+    I128_BYTE_LENGTH,
+    I256_BYTE_LENGTH,
+    I64_BYTE_LENGTH,
+    U128_BYTE_LENGTH,
+    U16_BYTE_LENGTH,
+    U256_BYTE_LENGTH,
+    U32_BYTE_LENGTH,
+    U64_BYTE_LENGTH,
+    U8_BYTE_LENGTH,
+} from '../utils/lengths';
 
 @final
 export class BytesReader {
@@ -17,41 +29,44 @@ export class BytesReader {
     }
 
     public readU8(): u8 {
-        this.verifyEnd(this.currentOffset + 1);
+        this.verifyEnd(this.currentOffset + U8_BYTE_LENGTH);
+
+        const value = this.buffer.getUint8(this.currentOffset);
+        this.currentOffset += U8_BYTE_LENGTH;
 
-        return this.buffer.getUint8(this.currentOffset++);
+        return value;
     }
 
     public readU16(): u16 {
-        this.verifyEnd(this.currentOffset + 2);
+        this.verifyEnd(this.currentOffset + U16_BYTE_LENGTH);
 
         const value = this.buffer.getUint16(this.currentOffset, true);
-        this.currentOffset += 2;
+        this.currentOffset += U16_BYTE_LENGTH;
 
         return value;
     }
 
     public readU32(le: boolean = true): u32 {
-        this.verifyEnd(this.currentOffset + 4);
+        this.verifyEnd(this.currentOffset + U32_BYTE_LENGTH);
 
         const value = this.buffer.getUint32(this.currentOffset, le);
-        this.currentOffset += 4;
+        this.currentOffset += U32_BYTE_LENGTH;
         return value;
     }
 
     public readU64(): u64 {
-        this.verifyEnd(this.currentOffset + 8);
+        this.verifyEnd(this.currentOffset + U64_BYTE_LENGTH);
 
         const value = this.buffer.getUint64(this.currentOffset, true);
-        this.currentOffset += 8;
+        this.currentOffset += U64_BYTE_LENGTH;
 
         return value;
     }
 
     public readU256(): u256 {
-        this.verifyEnd(this.currentOffset + 32);
+        this.verifyEnd(this.currentOffset + U256_BYTE_LENGTH);
 
-        const next32Bytes: u8[] = this.readBytesBE(32);
+        const next32Bytes: u8[] = this.readBytesBE(U256_BYTE_LENGTH);
 
         return u256.fromBytesBE(next32Bytes);
     }
@@ -67,26 +82,26 @@ export class BytesReader {
     }
 
     public readI64(): i64 {
-        this.verifyEnd(this.currentOffset + 8);
+        this.verifyEnd(this.currentOffset + I64_BYTE_LENGTH);
 
         const value = this.buffer.getInt64(this.currentOffset, true);
-        this.currentOffset += 8;
+        this.currentOffset += I64_BYTE_LENGTH;
 
         return value;
     }
 
     public readU128(): u128 {
-        this.verifyEnd(this.currentOffset + 16);
+        this.verifyEnd(this.currentOffset + U128_BYTE_LENGTH);
 
-        const next16Bytes: u8[] = this.readBytesBE(16);
+        const next16Bytes: u8[] = this.readBytesBE(U128_BYTE_LENGTH);
 
         return u128.fromBytesBE(next16Bytes);
     }
 
     public readI128(): i128 {
-        this.verifyEnd(this.currentOffset + 16);
+        this.verifyEnd(this.currentOffset + I128_BYTE_LENGTH);
 
-        const next16Bytes: u8[] = this.readBytesBE(16);
+        const next16Bytes: u8[] = this.readBytesBE(I128_BYTE_LENGTH);
 
         return i128.fromBytesBE(next16Bytes);
     }
@@ -173,9 +188,9 @@ export class BytesReader {
     }
 
     public readI256(): i256 {
-        this.verifyEnd(this.currentOffset + 32);
+        this.verifyEnd(this.currentOffset + I256_BYTE_LENGTH);
 
-        const next32Bytes: u8[] = this.readBytesBE(32);
+        const next32Bytes: u8[] = this.readBytesBE(I256_BYTE_LENGTH);
 
         return i256.fromBytesBE(next32Bytes);
     }

package/runtime/buffer/BytesWriter.ts

@@ -1,11 +1,22 @@
 import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
-import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
-import { Selector } from '../math/abi';
-import { BytesReader } from './BytesReader';
-import { Revert } from '../types/Revert';
 import { ArrayBuffer } from 'arraybuffer';
-import { i256 } from '../math/i256';
 import { AddressMap } from '../generic/AddressMap';
+import { Selector } from '../math/abi';
+import { i256 } from '../math/i256';
+import { Address } from '../types/Address';
+import { Revert } from '../types/Revert';
+import {
+    ADDRESS_BYTE_LENGTH,
+    I128_BYTE_LENGTH,
+    I256_BYTE_LENGTH,
+    U128_BYTE_LENGTH,
+    U16_BYTE_LENGTH,
+    U256_BYTE_LENGTH,
+    U32_BYTE_LENGTH,
+    U64_BYTE_LENGTH,
+    U8_BYTE_LENGTH,
+} from '../utils/lengths';
+import { BytesReader } from './BytesReader';
 
 @final
 export class BytesWriter {
@@ -24,26 +35,27 @@ export class BytesWriter {
     }
 
     public writeU8(value: u8): void {
-        this.allocSafe(1);
-        this.buffer.setUint8(this.currentOffset++, value);
+        this.allocSafe(U8_BYTE_LENGTH);
+        this.buffer.setUint8(this.currentOffset, value);
+        this.currentOffset += U8_BYTE_LENGTH;
     }
 
     public writeU16(value: u16): void {
-        this.allocSafe(2);
+        this.allocSafe(U16_BYTE_LENGTH);
         this.buffer.setUint16(this.currentOffset, value, true);
-        this.currentOffset += 2;
+        this.currentOffset += U16_BYTE_LENGTH;
     }
 
     public writeU32(value: u32, le: boolean = true): void {
-        this.allocSafe(4);
+        this.allocSafe(U32_BYTE_LENGTH);
         this.buffer.setUint32(this.currentOffset, value, le);
-        this.currentOffset += 4;
+        this.currentOffset += U32_BYTE_LENGTH;
     }
 
     public writeU64(value: u64): void {
-        this.allocSafe(8);
+        this.allocSafe(U64_BYTE_LENGTH);
         this.buffer.setUint64(this.currentOffset, value || 0, true);
-        this.currentOffset += 8;
+        this.currentOffset += U64_BYTE_LENGTH;
     }
 
     public writeAddressArray(value: Address[]): void {
@@ -65,10 +77,10 @@ export class BytesWriter {
     }
 
     public writeI256(value: i256): void {
-        this.allocSafe(32);
+        this.allocSafe(I256_BYTE_LENGTH);
 
         const bytes = value.toUint8Array(true);
-        for (let i: i32 = 0; i < 32; i++) {
+        for (let i: i32 = 0; i < I256_BYTE_LENGTH; i++) {
             this.writeU8(bytes[i] || 0);
         }
     }
@@ -78,34 +90,34 @@ export class BytesWriter {
     }
 
     public writeU256(value: u256): void {
-        this.allocSafe(32);
+        this.allocSafe(U256_BYTE_LENGTH);
 
         const bytes = value.toUint8Array(true);
-        for (let i: i32 = 0; i < 32; i++) {
+        for (let i: i32 = 0; i < U256_BYTE_LENGTH; i++) {
             this.writeU8(bytes[i] || 0);
         }
     }
 
     public writeI128(value: i128): void {
-        this.allocSafe(32);
+        this.allocSafe(I128_BYTE_LENGTH);
 
         const bytes = value.toUint8Array(true);
-        for (let i: i32 = 0; i < 32; i++) {
+        for (let i: i32 = 0; i < I128_BYTE_LENGTH; i++) {
             this.writeU8(bytes[i] || 0);
         }
     }
 
     public writeU128(value: u128): void {
-        this.allocSafe(16);
+        this.allocSafe(U128_BYTE_LENGTH);
 
         const bytes = value.toUint8Array(true);
-        for (let i: i32 = 0; i < 16; i++) {
+        for (let i: i32 = 0; i < U128_BYTE_LENGTH; i++) {
             this.writeU8(bytes[i] || 0);
         }
     }
 
     public writeTuple(value: u256[]): void {
-        this.allocSafe(4 + value.length * 32);
+        this.allocSafe(U32_BYTE_LENGTH + value.length * U256_BYTE_LENGTH);
         this.writeU32(u32(value.length));
 
         for (let i = 0; i < value.length; i++) {
@@ -116,8 +128,8 @@ export class BytesWriter {
     public writeU128Array(value: u128[]): void {
         if (value.length > 65535) throw new Revert('Array size is too large');
 
-        this.allocSafe(2 + value.length * 16);
-        this.writeU32(u16(value.length));
+        this.allocSafe(U16_BYTE_LENGTH + value.length * U128_BYTE_LENGTH);
+        this.writeU16(u16(value.length));
 
         for (let i = 0; i < value.length; i++) {
             this.writeU128(value[i]);
@@ -144,7 +156,7 @@ export class BytesWriter {
     public writeBytesWithLength(value: Uint8Array): void {
         const length: u32 = u32(value.length);
 
-        this.allocSafe(length + 4);
+        this.allocSafe(length + U32_BYTE_LENGTH);
         this.writeU32(length);
 
         for (let i: u32 = 0; i < length; i++) {
@@ -172,7 +184,7 @@ export class BytesWriter {
     public writeAddressValueTupleMap(map: AddressMap<u256>): void {
         if (map.size > 65535) throw new Revert('Map size is too large');
 
-        /*const requiredSize: u32 = 2 + map.size * (ADDRESS_BYTE_LENGTH + 32);
+        /*const requiredSize: u32 = U16_BYTE_LENGTH + map.size * (ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH);
 
         if (this.buffer.byteLength < requiredSize) {
             abort(
@@ -195,7 +207,7 @@ export class BytesWriter {
     public writeLimitedAddressBytesMap(map: AddressMap<Uint8Array[]>): void {
         if (map.size > 8) throw new Revert('Too many contract called.'); // no more than 8 different contracts.
 
-        /*let requiredSize: u32 = 1 + (map.size * ADDRESS_BYTE_LENGTH + 1);
+        /*let requiredSize: u32 = U8_BYTE_LENGTH + (map.size * ADDRESS_BYTE_LENGTH + U8_BYTE_LENGTH);
 
 
         for (let i = 0; i < map.size; i++) {
@@ -296,7 +308,9 @@ export class BytesWriter {
 
     private resize(size: u32): void {
         abort(
-            `Buffer is getting resized. This is very bad for performance. Expected size: ${this.buffer.byteLength + size} - Current size: ${this.buffer.byteLength}`,
+            `Buffer is getting resized. This is very bad for performance. Expected size: ${
+                this.buffer.byteLength + size
+            } - Current size: ${this.buffer.byteLength}`,
         );
 
         /*const buf: Uint8Array = new Uint8Array(u32(this.buffer.byteLength) + size);

package/runtime/contracts/DeployableOP_20.ts

@@ -12,6 +12,7 @@ import { Revert } from '../types/Revert';
 import { SafeMath } from '../types/SafeMath';
 
 import { Calldata } from '../types';
+import { BOOLEAN_BYTE_LENGTH, U256_BYTE_LENGTH } from '../utils/lengths';
 import { IOP_20 } from './interfaces/IOP_20';
 import { OP20InitParameters } from './interfaces/OP20InitParameters';
 import { OP_NET } from './OP_NET';
@@ -100,7 +101,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
 
     /** METHODS */
     public allowance(callData: Calldata): BytesWriter {
-        const response = new BytesWriter(32);
+        const response = new BytesWriter(U256_BYTE_LENGTH);
 
         const resp = this._allowance(callData.readAddress(), callData.readAddress());
         response.writeU256(resp);
@@ -115,7 +116,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         const value = callData.readU256();
 
         // Response buffer
-        const response = new BytesWriter(1);
+        const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
 
         const resp = this._approve(owner, spender, value);
         response.writeBoolean(resp);
@@ -124,7 +125,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     public balanceOf(callData: Calldata): BytesWriter {
-        const response = new BytesWriter(32);
+        const response = new BytesWriter(U256_BYTE_LENGTH);
         const address: Address = callData.readAddress();
         const resp = this._balanceOf(address);
 
@@ -134,7 +135,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     public burn(callData: Calldata): BytesWriter {
-        const response = new BytesWriter(1);
+        const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
         const resp = this._burn(callData.readU256());
         response.writeBoolean(resp);
 
@@ -142,7 +143,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     public transfer(callData: Calldata): BytesWriter {
-        const response = new BytesWriter(1);
+        const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
         const resp = this._transfer(callData.readAddress(), callData.readU256());
 
         response.writeBoolean(resp);
@@ -151,7 +152,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     public transferFrom(callData: Calldata): BytesWriter {
-        const response = new BytesWriter(1);
+        const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
         const resp = this._transferFrom(
             callData.readAddress(),
             callData.readAddress(),
@@ -168,7 +169,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
 
         switch (method) {
             case encodeSelector('decimals'):
-                response = new BytesWriter(1);
+                response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
                 response.writeU8(this.decimals);
                 break;
             case encodeSelector('name'):
@@ -180,11 +181,11 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
                 response.writeStringWithLength(this.symbol);
                 break;
             case encodeSelector('totalSupply'):
-                response = new BytesWriter(32);
+                response = new BytesWriter(U256_BYTE_LENGTH);
                 response.writeU256(this.totalSupply);
                 break;
             case encodeSelector('maximumSupply'):
-                response = new BytesWriter(32);
+                response = new BytesWriter(U256_BYTE_LENGTH);
                 response.writeU256(this.maxSupply);
                 break;
             case encodeSelector('allowance'):

package/runtime/contracts/OP_NET.ts

@@ -1,11 +1,12 @@
-import { IBTC } from '../interfaces/IBTC';
-import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
-import { Blockchain } from '../env';
 import { BytesWriter } from '../buffer/BytesWriter';
-import { encodeSelector, Selector } from '../math/abi';
-import { Revert } from '../types/Revert';
+import { Blockchain } from '../env';
 import { MAX_EVENT_DATA_SIZE, NetEvent } from '../events/NetEvent';
+import { IBTC } from '../interfaces/IBTC';
+import { encodeSelector, Selector } from '../math/abi';
 import { Calldata } from '../types';
+import { Address } from '../types/Address';
+import { Revert } from '../types/Revert';
+import { ADDRESS_BYTE_LENGTH } from '../utils/lengths';
 
 export class OP_NET implements IBTC {
     public get address(): Address {

package/runtime/env/BlockchainEnvironment.ts

@@ -1,30 +1,29 @@
-import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
-import { MemorySlotData } from '../memory/MemorySlot';
 import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesReader } from '../buffer/BytesReader';
 import { BytesWriter } from '../buffer/BytesWriter';
+import { OP_NET } from '../contracts/OP_NET';
 import { NetEvent } from '../events/NetEvent';
+import { MapU256 } from '../generic/MapU256';
+import { DeployContractResponse } from '../interfaces/DeployContractResponse';
 import { Potential } from '../lang/Definitions';
-import { OP_NET } from '../contracts/OP_NET';
+import { MemorySlotData } from '../memory/MemorySlot';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { PointerStorage } from '../types';
+import { Address } from '../types/Address';
+import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH } from '../utils/lengths';
+import { Block } from './classes/Block';
+import { Transaction } from './classes/Transaction';
 import {
     callContract,
-    deploy,
     deployFromAddress,
     emit,
     encodeAddress,
     loadPointer,
     log,
-    nextPointerGreaterThan,
     storePointer,
     validateBitcoinAddress,
     verifySchnorrSignature,
 } from './global';
-import { DeployContractResponse } from '../interfaces/DeployContractResponse';
-import { MapU256 } from '../generic/MapU256';
-import { Block } from './classes/Block';
-import { Transaction } from './classes/Transaction';
 
 export * from '../env/global';
 
@@ -186,8 +185,8 @@ export class BlockchainEnvironment {
         return reader.readAddress();
     }
 
-    public deployContract(hash: u256, bytecode: Uint8Array): DeployContractResponse {
-        const writer = new BytesWriter(32 + bytecode.length);
+    /*public deployContract(hash: u256, bytecode: Uint8Array): DeployContractResponse {
+        const writer = new BytesWriter(U256_BYTE_LENGTH + bytecode.length);
         writer.writeU256(hash);
         writer.writeBytes(bytecode);
 
@@ -199,13 +198,13 @@ export class BlockchainEnvironment {
         const contractAddress: Address = reader.readAddress();
 
         return new DeployContractResponse(virtualAddress, contractAddress);
-    }
+    }*/
 
     public deployContractFromExisting(
         existingAddress: Address,
         salt: u256,
     ): DeployContractResponse {
-        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH + 32);
+        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH);
         writer.writeAddress(existingAddress);
         writer.writeU256(salt);
 
@@ -220,6 +219,7 @@ export class BlockchainEnvironment {
         return new DeployContractResponse(virtualAddress, contractAddress);
     }
 
+    // TODO: Change MemorySlotData type to a Uint8Array instead of a u256.
     public getStorageAt(
         pointerHash: MemorySlotPointer,
         defaultValue: MemorySlotData<u256>,
@@ -233,12 +233,12 @@ export class BlockchainEnvironment {
         return defaultValue;
     }
 
-    public getNextPointerGreaterThan(
+    /*public getNextPointerGreaterThan(
         targetPointer: MemorySlotPointer,
         valueAtLeast: u256,
         lte: boolean = true,
     ): MemorySlotData<u256> {
-        const writer = new BytesWriter(65);
+        const writer = new BytesWriter(U256_BYTE_LENGTH * 2 + BOOLEAN_BYTE_LENGTH);
         writer.writeU256(targetPointer);
         writer.writeU256(valueAtLeast);
         writer.writeBoolean(lte);
@@ -247,14 +247,14 @@ export class BlockchainEnvironment {
         const reader: BytesReader = new BytesReader(result);
 
         return reader.readU256();
-    }
+    }*/
 
     public verifySchnorrSignature(
         publicKey: Address,
         signature: Uint8Array,
         hash: Uint8Array,
     ): boolean {
-        const writer = new BytesWriter(128);
+        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH + 64 + 32);
         writer.writeBytes(publicKey);
         writer.writeBytes(signature);
         writer.writeBytes(hash);
@@ -265,6 +265,7 @@ export class BlockchainEnvironment {
         return reader.readBoolean();
     }
 
+    // TODO: Change MemorySlotData type to a Uint8Array instead of a u256.
     public hasStorageAt(pointerHash: MemorySlotPointer): bool {
         // We mark zero as the default value for the storage, if something is 0, the storage slot get deleted or is non-existent
         const val: u256 = this.getStorageAt(pointerHash, u256.Zero);
@@ -293,7 +294,7 @@ export class BlockchainEnvironment {
     private _internalSetStorageAt(pointerHash: u256, value: MemorySlotData<u256>): void {
         this.storage.set(pointerHash, value);
 
-        const writer: BytesWriter = new BytesWriter(64);
+        const writer: BytesWriter = new BytesWriter(U256_BYTE_LENGTH * 2);
         writer.writeU256(pointerHash);
         writer.writeU256(value);
 
@@ -307,7 +308,7 @@ export class BlockchainEnvironment {
         }
 
         // we attempt to load the requested pointer.
-        const writer = new BytesWriter(32);
+        const writer = new BytesWriter(U256_BYTE_LENGTH);
         writer.writeU256(pointer);
 
         const result: Uint8Array = loadPointer(writer.getBuffer());

package/runtime/events/predefined/ApproveEvent.ts

@@ -1,12 +1,13 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { Address, ADDRESS_BYTE_LENGTH } from '../../types/Address';
-import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
+import { Address } from '../../types/Address';
+import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH } from '../../utils/lengths';
+import { NetEvent } from '../NetEvent';
 
 @final
 export class ApproveEvent extends NetEvent {
     constructor(owner: Address, spender: Address, value: u256) {
-        const data: BytesWriter = new BytesWriter(ADDRESS_BYTE_LENGTH * 2 + 32);
+        const data: BytesWriter = new BytesWriter(ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH);
         data.writeAddress(owner);
         data.writeAddress(spender);
         data.writeU256(value);

package/runtime/events/predefined/BurnEvent.ts

@@ -1,11 +1,12 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
+import { U256_BYTE_LENGTH } from '../../utils/lengths';
+import { NetEvent } from '../NetEvent';
 
 @final
 export class BurnEvent extends NetEvent {
     constructor(amount: u256) {
-        const data: BytesWriter = new BytesWriter(32);
+        const data: BytesWriter = new BytesWriter(U256_BYTE_LENGTH);
         data.writeU256(amount);
 
         super('Burn', data);

package/runtime/events/predefined/ClaimEvent.ts

@@ -1,11 +1,12 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
+import { U256_BYTE_LENGTH } from '../../utils/lengths';
+import { NetEvent } from '../NetEvent';
 
 @final
 export class ClaimEvent extends NetEvent {
     constructor(amount: u256) {
-        const data: BytesWriter = new BytesWriter(32);
+        const data: BytesWriter = new BytesWriter(U256_BYTE_LENGTH);
         data.writeU256(amount);
 
         super('Claim', data);

package/runtime/events/predefined/MintEvent.ts

@@ -1,12 +1,13 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
-import { Address, ADDRESS_BYTE_LENGTH } from '../../types/Address';
+import { Address } from '../../types/Address';
+import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH } from '../../utils/lengths';
+import { NetEvent } from '../NetEvent';
 
 @final
 export class MintEvent extends NetEvent {
     constructor(address: Address, amount: u256) {
-        const data: BytesWriter = new BytesWriter(32 + ADDRESS_BYTE_LENGTH);
+        const data: BytesWriter = new BytesWriter(ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH);
 
         data.writeAddress(address);
         data.writeU256(amount);

package/runtime/events/predefined/StakeEvent.ts

@@ -1,11 +1,12 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
+import { U256_BYTE_LENGTH } from '../../utils/lengths';
+import { NetEvent } from '../NetEvent';
 
 @final
 export class StakeEvent extends NetEvent {
     constructor(amount: u256) {
-        const data: BytesWriter = new BytesWriter(32);
+        const data: BytesWriter = new BytesWriter(U256_BYTE_LENGTH);
         data.writeU256(amount);
 
         super('Stake', data);

package/runtime/events/predefined/TransferEvent.ts

@@ -1,12 +1,13 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { NetEvent } from '../NetEvent';
-import { Address, ADDRESS_BYTE_LENGTH } from '../../types/Address';
 import { BytesWriter } from '../../buffer/BytesWriter';
+import { Address } from '../../types/Address';
+import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH } from '../../utils/lengths';
+import { NetEvent } from '../NetEvent';
 
 @final
 export class TransferEvent extends NetEvent {
     constructor(from: Address, to: Address, amount: u256) {
-        const data: BytesWriter = new BytesWriter(ADDRESS_BYTE_LENGTH * 2 + 32);
+        const data: BytesWriter = new BytesWriter(ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH);
         data.writeAddress(from);
         data.writeAddress(to);
         data.writeU256(amount);

package/runtime/events/predefined/UnstakeEvent.ts

@@ -1,11 +1,12 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { NetEvent } from '../NetEvent';
 import { BytesWriter } from '../../buffer/BytesWriter';
+import { U256_BYTE_LENGTH } from '../../utils/lengths';
+import { NetEvent } from '../NetEvent';
 
 @final
 export class UnstakeEvent extends NetEvent {
     constructor(amount: u256) {
-        const data: BytesWriter = new BytesWriter(32);
+        const data: BytesWriter = new BytesWriter(U256_BYTE_LENGTH);
         data.writeU256(amount);
 
         super('Unstake', data);

package/runtime/index.ts

@@ -70,6 +70,7 @@ export * from './storage/StoredString';
 export * from './storage/StoredAddress';
 export * from './storage/StoredBoolean';
 export * from './storage/Serializable';
+export * from './storage/StoredAddressArray';
 
 export * from './storage/StorageBacked';
 export * from './storage/StorageSlot';

package/runtime/shared-libraries/OP20Utils.ts

@@ -1,8 +1,9 @@
-import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodeSelector, Selector } from '../math/abi';
+import { Address } from '../types/Address';
+import { ADDRESS_BYTE_LENGTH, SELECTOR_BYTE_LENGTH } from '../utils/lengths';
 
 export class OP20Utils {
     public static get BALANCE_OF_SELECTOR(): Selector {
@@ -10,7 +11,7 @@ export class OP20Utils {
     }
 
     public static balanceOf(token: Address, owner: Address): u256 {
-        const calldata: BytesWriter = new BytesWriter(4 + ADDRESS_BYTE_LENGTH);
+        const calldata: BytesWriter = new BytesWriter(SELECTOR_BYTE_LENGTH + ADDRESS_BYTE_LENGTH);
         calldata.writeSelector(OP20Utils.BALANCE_OF_SELECTOR);
         calldata.writeAddress(owner);
 

package/runtime/shared-libraries/TransferHelper.ts

@@ -1,9 +1,10 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { encodeSelector, Selector } from '../math/abi';
-import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
+import { encodeSelector, Selector } from '../math/abi';
+import { Address } from '../types/Address';
 import { Revert } from '../types/Revert';
+import { ADDRESS_BYTE_LENGTH, SELECTOR_BYTE_LENGTH, U256_BYTE_LENGTH } from '../utils/lengths';
 
 export class TransferHelper {
     public static get APPROVE_SELECTOR(): Selector {
@@ -19,7 +20,9 @@ export class TransferHelper {
     }
 
     public static safeApprove(token: Address, spender: Address, amount: u256): void {
-        const calldata = new BytesWriter(4 + ADDRESS_BYTE_LENGTH + 32);
+        const calldata = new BytesWriter(
+            SELECTOR_BYTE_LENGTH + ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH,
+        );
         calldata.writeSelector(this.APPROVE_SELECTOR);
         calldata.writeAddress(spender);
         calldata.writeU256(amount);
@@ -33,7 +36,9 @@ export class TransferHelper {
     }
 
     public static safeTransfer(token: Address, to: Address, amount: u256): void {
-        const calldata = new BytesWriter(4 + ADDRESS_BYTE_LENGTH + 32);
+        const calldata = new BytesWriter(
+            SELECTOR_BYTE_LENGTH + ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH,
+        );
         calldata.writeSelector(this.TRANSFER_SELECTOR);
         calldata.writeAddress(to);
         calldata.writeU256(amount);
@@ -47,9 +52,10 @@ export class TransferHelper {
     }
 
     public static safeTransferFrom(token: Address, from: Address, to: Address, amount: u256): void {
-        const calldata = new BytesWriter(4 + ADDRESS_BYTE_LENGTH + ADDRESS_BYTE_LENGTH + 32);
+        const calldata = new BytesWriter(
+            SELECTOR_BYTE_LENGTH + ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH,
+        );
         calldata.writeSelector(this.TRANSFER_FROM_SELECTOR);
-
         calldata.writeAddress(from);
         calldata.writeAddress(to);
         calldata.writeU256(amount);

package/runtime/storage/Serializable.ts

@@ -1,10 +1,11 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
+import { BytesReader } from '../buffer/BytesReader';
+import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
+import { encodePointer } from '../math/abi';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
-import { BytesWriter } from '../buffer/BytesWriter';
-import { BytesReader } from '../buffer/BytesReader';
 import { Revert } from '../types/Revert';
-import { encodePointer } from '../math/abi';
+import { U256_BYTE_LENGTH } from '../utils/lengths';
 
 // Similar to a struct in Solidity. (Use in worst case scenario, consume a lot of gas)
 export abstract class Serializable {
@@ -99,7 +100,7 @@ export abstract class Serializable {
     }
 
     protected getPointer(subPointer: u256, index: u8): u256 {
-        const writer = new BytesWriter(32);
+        const writer = new BytesWriter(U256_BYTE_LENGTH);
         writer.writeU256(subPointer);
 
         // Discard the first byte for offset.

package/runtime/storage/StoredAddress.ts

@@ -1,7 +1,7 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
+import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
-import { BytesWriter } from '../buffer/BytesWriter';
 import { Address } from '../types/Address';
 
 @final
@@ -9,10 +9,7 @@ export class StoredAddress {
     private readonly addressPointer: u256;
     private readonly defaultValue: u256;
 
-    constructor(
-        public pointer: u16,
-        defaultValue: Address,
-    ) {
+    constructor(public pointer: u16, defaultValue: Address) {
         const writer = new BytesWriter(32);
 
         this.defaultValue = u256.fromBytes(defaultValue);

package/runtime/storage/StoredAddressArray.ts

@@ -1,13 +1,14 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { Blockchain } from '../env';
 import { BytesWriter } from '../buffer/BytesWriter';
-import { SafeMath } from '../types/SafeMath';
+import { Blockchain } from '../env';
 import { Address } from '../types/Address';
 import { Revert } from '../types/Revert';
+import { SafeMath } from '../types/SafeMath';
 
 /**
  * @class StoredAddressArray
- * @description Manages an array of u256 values across multiple storage slots. Each slot holds one u256 value.
+ * @description Manages an array of Address values across multiple storage slots.
+ * Each slot holds one Address (stored as u256 in storage).
  */
 @final
 export class StoredAddressArray {
@@ -15,7 +16,7 @@ export class StoredAddressArray {
     private readonly lengthPointer: u256;
 
     // Internal cache for storage slots
-    private _values: Map<u64, Address> = new Map(); // Map from slotIndex to u256 value
+    private _values: Map<u64, Address> = new Map(); // Map from slotIndex to Address value
     private _isLoaded: Set<u64> = new Set(); // Set of slotIndexes that are loaded
     private _isChanged: Set<u64> = new Set(); // Set of slotIndexes that are modified
 
@@ -26,25 +27,20 @@ export class StoredAddressArray {
     private _isChangedStartIndex: bool = false; // Indicates if the startIndex has been modified
 
     // Define a maximum allowed length to prevent excessive storage usage
-    private readonly MAX_LENGTH: u64 = u64(u32.MAX_VALUE - 1); // we need to check what happen in overflow situation to be able to set it to u64.MAX_VALUE
+    private readonly MAX_LENGTH: u64 = u64(u32.MAX_VALUE - 1);
 
     /**
      * @constructor
      * @param {u16} pointer - The primary pointer identifier.
      * @param {Uint8Array} subPointer - The sub-pointer for memory slot addressing.
-     * @param {u256} defaultValue - The default u256 value if storage is uninitialized.
+     * @param {Address} defaultValue - The default Address value if storage is uninitialized.
      */
-    constructor(
-        public pointer: u16,
-        public subPointer: Uint8Array,
-        private defaultValue: Address,
-    ) {
-        // Initialize the base u256 pointer using the primary pointer and subPointer
+    constructor(public pointer: u16, public subPointer: Uint8Array, private defaultValue: Address) {
+        // Initialize the base pointer
         const writer = new BytesWriter(32);
         writer.writeU16(pointer);
         writer.writeBytes(subPointer);
 
-        // Initialize the base and length pointers
         const baseU256Pointer = u256.fromBytes(writer.getBuffer(), true);
         const lengthPointer = baseU256Pointer.clone();
 
@@ -60,7 +56,7 @@ export class StoredAddressArray {
     /**
      * @method get
      * @description Retrieves the Address value at the specified global index.
-     * @param {u64} index - The global index (0 to ∞) of the Address value to retrieve.
+     * @param {u64} index - The global index of the Address to retrieve.
      * @returns {Address} - The Address value at the specified index.
      */
     @inline
@@ -75,7 +71,7 @@ export class StoredAddressArray {
     /**
      * @method set
      * @description Sets the Address value at the specified global index.
-     * @param {u64} index - The global index (0 to ∞) of the Address value to set.
+     * @param {u64} index - The global index of the Address to set.
      * @param {Address} value - The Address value to assign.
      */
     @inline
@@ -91,10 +87,38 @@ export class StoredAddressArray {
         }
     }
 
+    /**
+     * @method indexOf
+     * @description Searches for the first occurrence of the specified Address value and returns its index.
+     * @param {Address} value - The Address to locate.
+     * @returns {i64} - The index of the first occurrence, or -1 if not found.
+     */
+    @inline
+    public indexOf(value: Address): i64 {
+        for (let i: u64 = 0; i < this._length; i++) {
+            const currentValue = this.get(i);
+            if (currentValue == value) {
+                return i64(i);
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * @method contains
+     * @description Determines whether the array contains the specified Address value.
+     * @param {Address} value - The Address to locate.
+     * @returns {boolean} - True if found; otherwise, false.
+     */
+    @inline
+    public contains(value: Address): boolean {
+        return this.indexOf(value) !== -1;
+    }
+
     /**
      * @method push
-     * @description Appends a new u256 value to the end of the array.
-     * @param {u256} value - The u256 value to append.
+     * @description Appends a new Address value to the end of the array.
+     * @param {Address} value - The Address to append.
      */
     public push(value: Address): void {
         if (this._length >= this.MAX_LENGTH) {
@@ -104,23 +128,22 @@ export class StoredAddressArray {
         }
 
         const newIndex: u64 = this._length;
-        const effectiveIndex: u64 = this._startIndex + newIndex;
         const wrappedIndex: u64 =
-            effectiveIndex < this.MAX_LENGTH ? effectiveIndex : effectiveIndex % this.MAX_LENGTH;
+            newIndex < this.MAX_LENGTH ? newIndex : newIndex % this.MAX_LENGTH;
         const slotIndex: u32 = <u32>wrappedIndex;
 
-        // Ensure the slot is loaded
         this.ensureValues(slotIndex);
-
-        // Set the new value
         this._values.set(slotIndex, value);
         this._isChanged.add(slotIndex);
 
-        // Increment the length
         this._length += 1;
         this._isChangedLength = true;
     }
 
+    /**
+     * @method deleteLast
+     * @description Deletes the last element from the array.
+     */
     public deleteLast(): void {
         if (this._length === 0) {
             throw new Revert('Delete operation failed: Array is empty.');
@@ -136,11 +159,15 @@ export class StoredAddressArray {
             this._isChanged.add(slotIndex);
         }
 
-        // Decrement the length
         this._length -= 1;
         this._isChangedLength = true;
     }
 
+    /**
+     * @method setStartingIndex
+     * @description Sets the starting index of the array.
+     * @param {u64} index - The new starting index.
+     */
     public setStartingIndex(index: u64): void {
         this._startIndex = index;
         this._isChangedStartIndex = true;
@@ -148,8 +175,8 @@ export class StoredAddressArray {
 
     /**
      * @method delete
-     * @description Deletes the Address value at the specified index by setting it to zero. Does not reorder the array.
-     * @param {u64} index - The global index of the u256 value to delete.
+     * @description Deletes the Address value at the specified index by setting it to defaultValue.
+     * @param {u64} index - The global index of the Address value to delete.
      */
     public delete(index: u64): void {
         if (index >= this._length) {
@@ -168,8 +195,7 @@ export class StoredAddressArray {
 
     /**
      * @method shift
-     * @description Removes the first element of the array by setting it to this.defaultValue, decrementing the length, and incrementing the startIndex.
-     *              If the startIndex reaches the maximum value of u64, it wraps around to 0.
+     * @description Removes the first element of the array.
      */
     public shift(): void {
         if (this._length === 0) {
@@ -186,7 +212,6 @@ export class StoredAddressArray {
             this._isChanged.add(slotIndex);
         }
 
-        // Decrement the length
         this._length -= 1;
         this._isChangedLength = true;
 
@@ -201,7 +226,7 @@ export class StoredAddressArray {
 
     /**
      * @method save
-     * @description Persists all cached u256 values, the length, and the startIndex to their respective storage slots if any have been modified.
+     * @description Persists all changes to storage.
      */
     public save(): void {
         // Save all changed slots
@@ -227,10 +252,10 @@ export class StoredAddressArray {
 
     /**
      * @method deleteAll
-     * @description Deletes all storage slots by setting them to this.defaultValue, including the length and startIndex slots.
+     * @description Deletes the entire array and resets length and startIndex.
      */
     public deleteAll(): void {
-        // Iterate over all loaded slots and clear them
+        // Clear all loaded slots
         const keys = this._values.keys();
         for (let i = 0; i < keys.length; i++) {
             const slotIndex = keys[i];
@@ -238,7 +263,7 @@ export class StoredAddressArray {
             Blockchain.setStorageAt(storagePointer, u256.fromBytes(this.defaultValue));
         }
 
-        // Reset the length and startIndex to zero
+        // Reset the length and startIndex
         const zeroLengthAndStartIndex = u256.Zero;
         Blockchain.setStorageAt(this.lengthPointer, zeroLengthAndStartIndex);
         this._length = 0;
@@ -254,9 +279,9 @@ export class StoredAddressArray {
 
     /**
      * @method setMultiple
-     * @description Sets multiple u256 values starting from a specific global index.
+     * @description Sets multiple Address values starting from a specific global index.
      * @param {u32} startIndex - The starting global index.
-     * @param {u256[]} values - An array of u256 values to set.
+     * @param {Address[]} values - An array of Address values to set.
      */
     @inline
     public setMultiple(startIndex: u32, values: Address[]): void {
@@ -267,10 +292,10 @@ export class StoredAddressArray {
 
     /**
      * @method getAll
-     * @description Retrieves a range of values starting from a specific global index.
-     * @param {u32} startIndex - The starting global index.
-     * @param {u32} count - The number of values to retrieve.
-     * @returns {Address[]} - An array containing the retrieved Address values.
+     * @description Retrieves a range of Address values.
+     * @param {u32} startIndex - The start index.
+     * @param {u32} count - The number of items to get.
+     * @returns {Address[]} - The requested Address values.
      */
     @inline
     public getAll(startIndex: u32, count: u32): Address[] {
@@ -284,8 +309,8 @@ export class StoredAddressArray {
 
     /**
      * @method toString
-     * @description Returns a string representation of all cached values.
-     * @returns {string} - A string in the format "[value0, value1, ..., valueN]".
+     * @description Returns a string representation of the array.
+     * @returns {string} - A string of the form "[addr0, addr1, ...]".
      */
     @inline
     public toString(): string {
@@ -304,7 +329,7 @@ export class StoredAddressArray {
     /**
      * @method toBytes
      * @description Returns the packed Address values as a byte array.
-     * @returns {u8[]} - The packed values in byte form.
+     * @returns {u8[]} - The packed byte array.
      */
     @inline
     public toBytes(): u8[] {
@@ -313,7 +338,7 @@ export class StoredAddressArray {
             this.ensureValues(i);
             const value = this._values.get(i);
             if (value) {
-                const valueBytes = value;
+                const valueBytes = value; // Address is assumed to be or contain a Uint8Array
                 for (let j: u32 = 0; j < valueBytes.length; j++) {
                     bytes.push(valueBytes[j]);
                 }
@@ -324,16 +349,14 @@ export class StoredAddressArray {
 
     /**
      * @method reset
-     * @description Resets all cached u256 values to zero and marks them as changed, including resetting the length and startIndex.
+     * @description Resets the array by clearing all elements and resetting length and startIndex to zero.
      */
     @inline
     public reset(): void {
-        // Reset the length and startIndex to zero
         this._length = 0;
         this._startIndex = 0;
         this._isChangedLength = true;
         this._isChangedStartIndex = true;
-
         this.save();
     }
 
@@ -358,8 +381,8 @@ export class StoredAddressArray {
 
     /**
      * @method setLength
-     * @description Sets the length of the array.
-     * @param {u64} newLength - The new length to set.
+     * @description Sets the length of the array, truncating if necessary.
+     * @param {u64} newLength - The new length.
      */
     public setLength(newLength: u64): void {
         if (newLength > this.MAX_LENGTH) {
@@ -380,15 +403,15 @@ export class StoredAddressArray {
     /**
      * @private
      * @method ensureValues
-     * @description Loads and caches the u256 value from the specified storage slot.
+     * @description Loads and caches the Address from the specified storage slot if not already loaded.
      * @param {u32} slotIndex - The index of the storage slot.
      */
     private ensureValues(slotIndex: u32): void {
         if (!this._isLoaded.has(slotIndex)) {
             const storagePointer = this.calculateStoragePointer(slotIndex);
-            const storedU256 = Blockchain.getStorageAt(storagePointer, u256.Zero);
+            const storedU256: u256 = Blockchain.getStorageAt(storagePointer, u256.Zero);
             const storedAddress: Address =
-                storedU256 === u256.Zero ? this.defaultValue : new Address(storedU256.toBytes());
+                storedU256 == u256.Zero ? this.defaultValue : new Address(storedU256.toBytes());
             this._values.set(slotIndex, storedAddress);
             this._isLoaded.add(slotIndex);
         }
@@ -397,13 +420,13 @@ export class StoredAddressArray {
     /**
      * @private
      * @method calculateStoragePointer
-     * @description Calculates the storage pointer for a given slot index by incrementing the base pointer.
-     * @param {u32} slotIndex - The index of the storage slot.
+     * @description Calculates the storage pointer for a given slot index.
+     * @param {u64} slotIndex - The index of the storage slot.
      * @returns {u256} - The calculated storage pointer.
      */
     private calculateStoragePointer(slotIndex: u64): u256 {
         // Each slot is identified by baseU256Pointer + slotIndex + 1
-        // Slot 0: baseU256Pointer + 1 (first element)
+        // Slot 0: baseU256Pointer + 1
         // Slot 1: baseU256Pointer + 2, etc.
         return SafeMath.add(this.baseU256Pointer, u256.fromU64(slotIndex + 1));
     }

package/runtime/storage/StoredBooleanArray.ts

@@ -1,8 +1,8 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { Blockchain } from '../env';
 import { BytesWriter } from '../buffer/BytesWriter';
-import { SafeMath } from '../types/SafeMath';
+import { Blockchain } from '../env';
 import { Revert } from '../types/Revert';
+import { SafeMath } from '../types/SafeMath';
 
 /**
  * @class StoredBooleanArray
@@ -33,11 +33,7 @@ export class StoredBooleanArray {
      * @param {Uint8Array} subPointer - The sub-pointer for memory slot addressing.
      * @param {u256} defaultValue - The default u256 value if storage is uninitialized.
      */
-    constructor(
-        public pointer: u16,
-        public subPointer: Uint8Array,
-        private defaultValue: u256,
-    ) {
+    constructor(public pointer: u16, public subPointer: Uint8Array, private defaultValue: u256) {
         // Initialize the base u256 pointer using the primary pointer and subPointer
         const writer = new BytesWriter(32);
         writer.writeU16(pointer);

package/runtime/storage/StoredString.ts

@@ -1,15 +1,13 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
+import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
-import { SafeMath } from '../types/SafeMath';
 import { encodePointer } from '../math/abi';
-import { BytesWriter } from '../buffer/BytesWriter';
+import { SafeMath } from '../types/SafeMath';
+import { U256_BYTE_LENGTH } from '../utils/lengths';
 
 @final
 export class StoredString {
-    constructor(
-        public pointer: u16,
-        private defaultValue?: string,
-    ) {}
+    constructor(public pointer: u16, private defaultValue?: string) {}
 
     private _value: string = '';
 
@@ -33,7 +31,7 @@ export class StoredString {
     }
 
     private getPointer(key: u256): u256 {
-        const buf = new BytesWriter(32);
+        const buf = new BytesWriter(U256_BYTE_LENGTH);
         buf.writeU256(key);
 
         return encodePointer(this.pointer, buf.getBuffer());

package/runtime/storage/StoredU256.ts

@@ -1,9 +1,10 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
-import { SafeMath } from '../types/SafeMath';
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
-import { BytesWriter } from '../buffer/BytesWriter';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { SafeMath } from '../types/SafeMath';
+import { U256_BYTE_LENGTH } from '../utils/lengths';
 
 @final
 export class StoredU256 {
@@ -14,7 +15,7 @@ export class StoredU256 {
         public subPointer: MemorySlotPointer,
         private defaultValue: u256,
     ) {
-        const writer = new BytesWriter(32);
+        const writer = new BytesWriter(U256_BYTE_LENGTH);
         writer.writeU256(subPointer);
 
         this.u256Pointer = encodePointer(pointer, writer.getBuffer());

package/runtime/storage/StoredU64.ts

@@ -1,8 +1,9 @@
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
-import { BytesWriter } from '../buffer/BytesWriter';
-import { u256 } from '@btc-vision/as-bignum/assembly';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { U256_BYTE_LENGTH } from '../utils/lengths';
 
 /**
  * @class StoredU64
@@ -32,7 +33,7 @@ export class StoredU64 {
         public subPointer: MemorySlotPointer,
         private defaultValue: u256,
     ) {
-        const writer = new BytesWriter(32);
+        const writer = new BytesWriter(U256_BYTE_LENGTH);
         writer.writeU256(subPointer);
 
         this.u256Pointer = encodePointer(pointer, writer.getBuffer());

package/runtime/tests/tests.ts

@@ -2,10 +2,11 @@ import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { Box } from '../utils/box';
+import { U256_BYTE_LENGTH } from '../utils/lengths';
 import { assertEq } from './assert';
 
 export function test_encode(): void {
-    const writer = new BytesWriter(64);
+    const writer = new BytesWriter(U256_BYTE_LENGTH * 2);
     writer.writeU256(u256.from(10));
     writer.writeU256(u256.from(20));
     const buffer = writer.getBuffer().buffer;

package/runtime/types/Address.ts

@@ -1,8 +1,7 @@
 import { Potential } from '../lang/Definitions';
-import { bech32m as _bech32m, toWords } from '../utils/b32';
 import { decodeHexArray, encodeHexFromBuffer } from '../utils';
-
-export const ADDRESS_BYTE_LENGTH: i32 = 32;
+import { bech32m as _bech32m, toWords } from '../utils/b32';
+import { ADDRESS_BYTE_LENGTH } from '../utils/lengths';
 
 @final
 export class Address extends Uint8Array {

package/runtime/utils/index.ts

@@ -1,3 +1,4 @@
-export * from './hex';
 export * from './box';
 export * from './encodings';
+export * from './hex';
+export * from './lengths';

package/runtime/utils/lengths.ts

@@ -0,0 +1,18 @@
+export const ADDRESS_BYTE_LENGTH: i32 = 32;
+export const SELECTOR_BYTE_LENGTH: i32 = 4;
+
+export const U256_BYTE_LENGTH: i32 = 32;
+export const U128_BYTE_LENGTH: i32 = 16;
+export const U64_BYTE_LENGTH: i32 = 8;
+export const U32_BYTE_LENGTH: i32 = 4;
+export const U16_BYTE_LENGTH: i32 = 2;
+export const U8_BYTE_LENGTH: i32 = 1;
+
+export const I256_BYTE_LENGTH: i32 = 32;
+export const I128_BYTE_LENGTH: i32 = 16;
+export const I64_BYTE_LENGTH: i32 = 8;
+export const I32_BYTE_LENGTH: i32 = 4;
+export const I16_BYTE_LENGTH: i32 = 2;
+export const I8_BYTE_LENGTH: i32 = 1;
+
+export const BOOLEAN_BYTE_LENGTH: i32 = 1;