@btc-vision/btc-runtime 1.3.16 → 1.3.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.3.16",
+    "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,13 +1,18 @@
-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,
     deployFromAddress,
@@ -19,10 +24,6 @@ import {
     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';
 
@@ -185,7 +186,7 @@ export class BlockchainEnvironment {
     }
 
     /*public deployContract(hash: u256, bytecode: Uint8Array): DeployContractResponse {
-        const writer = new BytesWriter(32 + bytecode.length);
+        const writer = new BytesWriter(U256_BYTE_LENGTH + bytecode.length);
         writer.writeU256(hash);
         writer.writeBytes(bytecode);
 
@@ -203,7 +204,7 @@ export class BlockchainEnvironment {
         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);
 
@@ -237,7 +238,7 @@ export class BlockchainEnvironment {
         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);
@@ -253,7 +254,7 @@ export class BlockchainEnvironment {
         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);
@@ -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/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,9 +1,9 @@
 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
@@ -35,11 +35,7 @@ export class StoredAddressArray {
      * @param {Uint8Array} subPointer - The sub-pointer for memory slot addressing.
      * @param {Address} defaultValue - The default Address value if storage is uninitialized.
      */
-    constructor(
-        public pointer: u16,
-        public subPointer: Uint8Array,
-        private defaultValue: Address,
-    ) {
+    constructor(public pointer: u16, public subPointer: Uint8Array, private defaultValue: Address) {
         // Initialize the base pointer
         const writer = new BytesWriter(32);
         writer.writeU16(pointer);

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;