@btc-vision/btc-runtime 1.1.6 → 1.1.8

package/runtime/contracts/OP_NET.ts

@@ -1,5 +1,5 @@
 import { IBTC } from '../interfaces/IBTC';
-import { Address } from '../types/Address';
+import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { Blockchain } from '../env';
 import { Calldata } from '../universal/ABIRegistry';
 import { BytesWriter } from '../buffer/BytesWriter';
@@ -14,8 +14,6 @@ export class OP_NET implements IBTC {
         false,
     );
 
-    constructor() {}
-
     public get address(): string {
         return Blockchain.contractAddress;
     }
@@ -42,13 +40,15 @@ export class OP_NET implements IBTC {
     }
 
     public callView(method: Selector): BytesWriter {
-        const response = new BytesWriter();
+        let response: BytesWriter;
 
         switch (method) {
             case encodeSelector('address'):
+                response = new BytesWriter(ADDRESS_BYTE_LENGTH);
                 response.writeAddress(this.address);
                 break;
             case encodeSelector('owner'):
+                response = new BytesWriter(ADDRESS_BYTE_LENGTH);
                 response.writeAddress(this.owner);
                 break;
             default:

package/runtime/env/BTCEnvironment.ts

@@ -1,4 +1,4 @@
-import { Address, PotentialAddress } from '../types/Address';
+import { Address, ADDRESS_BYTE_LENGTH, PotentialAddress } from '../types/Address';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { MemorySlotData } from '../memory/MemorySlot';
 import { u256 } from 'as-bignum/assembly';
@@ -35,8 +35,6 @@ export class BlockchainEnvironment {
 
     private _selfContract: Potential<OP_NET> = null;
 
-    constructor() {}
-
     private _txOrigin: PotentialAddress = null;
 
     public get txOrigin(): Address {
@@ -66,13 +64,7 @@ export class BlockchainEnvironment {
     private _contract: Potential<() => OP_NET> = null;
 
     public get contract(): OP_NET {
-        if (!this._contract) {
-            throw this.error('Contract is required');
-        }
-
-        if (!this._selfContract) {
-            this._selfContract = this._contract();
-        }
+        this.createContractIfNotExists();
 
         return this._selfContract as OP_NET;
     }
@@ -133,7 +125,7 @@ export class BlockchainEnvironment {
 
         this._timestamp = reader.readU64();
 
-        this.contract;
+        this.createContractIfNotExists();
     }
 
     public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
@@ -145,7 +137,7 @@ export class BlockchainEnvironment {
             throw this.error('Destination contract is required');
         }
 
-        const call = new BytesWriter();
+        const call = new BytesWriter(ADDRESS_BYTE_LENGTH + calldata.bufferLength() + 4);
         call.writeAddress(destinationContract);
         call.writeBytesWithLength(calldata.getBuffer());
 
@@ -155,7 +147,7 @@ export class BlockchainEnvironment {
     }
 
     public log(data: string): void {
-        const writer = new BytesWriter();
+        const writer = new BytesWriter(data.length + 2);
         writer.writeStringWithLength(data);
 
         const buffer = writer.getBuffer();
@@ -183,7 +175,7 @@ export class BlockchainEnvironment {
             const event: NetEvent = this.events[i];
 
             buffer.writeStringWithLength(event.eventType);
-            buffer.writeU64(event.getEventDataSelector());
+            buffer.writeU64(0); //event.getEventDataSelector()
             buffer.writeBytesWithLength(event.getEventData());
         }
 
@@ -191,7 +183,7 @@ export class BlockchainEnvironment {
     }
 
     public encodeVirtualAddress(virtualAddress: Uint8Array): Address {
-        const writer: BytesWriter = new BytesWriter();
+        const writer: BytesWriter = new BytesWriter(virtualAddress.byteLength + 4);
         writer.writeBytesWithLength(virtualAddress);
 
         const buffer: Uint8Array = writer.getBuffer();
@@ -221,7 +213,7 @@ export class BlockchainEnvironment {
         existingAddress: Address,
         salt: u256,
     ): DeployContractResponse {
-        const writer = new BytesWriter();
+        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH + 32);
         writer.writeAddress(existingAddress);
         writer.writeU256(salt);
 
@@ -280,6 +272,16 @@ export class BlockchainEnvironment {
         return ABIRegistry.getWriteMethods();
     }
 
+    private createContractIfNotExists(): void {
+        if (!this._contract) {
+            throw this.error('Contract is required');
+        }
+
+        if (!this._selfContract) {
+            this._selfContract = this._contract();
+        }
+    }
+
     private error(msg: string): Error {
         return new Error(`${BlockchainEnvironment.runtimeException}: ${msg}`);
     }
@@ -287,7 +289,7 @@ export class BlockchainEnvironment {
     private _internalSetStorageAt(pointerHash: u256, value: MemorySlotData<u256>): void {
         this.storage.set(pointerHash, value);
 
-        const writer: BytesWriter = new BytesWriter();
+        const writer: BytesWriter = new BytesWriter(64);
         writer.writeU256(pointerHash);
         writer.writeU256(value);
 
@@ -301,7 +303,7 @@ export class BlockchainEnvironment {
         }
 
         // we attempt to load the requested pointer.
-        const writer = new BytesWriter();
+        const writer = new BytesWriter(32);
         writer.writeU256(pointer);
 
         const result: Uint8Array = loadPointer(writer.getBuffer());

package/runtime/env/global.ts

@@ -1,32 +1,32 @@
-// @ts-ignore
-@external('env', 'load')
-export declare function loadPointer(data: Uint8Array): Uint8Array;
-
-// @ts-ignore
-@external('env', 'store')
-export declare function storePointer(data: Uint8Array): Uint8Array;
-
-// @ts-ignore
-@external('env', 'deploy')
-export declare function deploy(data: Uint8Array): Uint8Array;
-
-// @ts-ignore
-@external('env', 'deployFromAddress')
-export declare function deployFromAddress(data: Uint8Array): Uint8Array;
-
-// @ts-ignore
-@external('env', 'call')
-export declare function callContract(data: Uint8Array): Uint8Array;
-
-// @ts-ignore
-@external('env', 'log')
-export declare function log(data: Uint8Array): void;
-
-// @ts-ignore
-@external('env', 'encodeAddress')
-export declare function encodeAddress(data: Uint8Array): Uint8Array;
-
-
-// @ts-ignore
-@external('env', 'sha256')
-export declare function sha256(data: Uint8Array): Uint8Array;
+// @ts-ignore
+@external('env', 'load')
+export declare function loadPointer(data: Uint8Array): Uint8Array;
+
+// @ts-ignore
+@external('env', 'store')
+export declare function storePointer(data: Uint8Array): Uint8Array;
+
+// @ts-ignore
+@external('env', 'deploy')
+export declare function deploy(data: Uint8Array): Uint8Array;
+
+// @ts-ignore
+@external('env', 'deployFromAddress')
+export declare function deployFromAddress(data: Uint8Array): Uint8Array;
+
+// @ts-ignore
+@external('env', 'call')
+export declare function callContract(data: Uint8Array): Uint8Array;
+
+// @ts-ignore
+@external('env', 'log')
+export declare function log(data: Uint8Array): void;
+
+// @ts-ignore
+@external('env', 'encodeAddress')
+export declare function encodeAddress(data: Uint8Array): Uint8Array;
+
+
+// @ts-ignore
+@external('env', 'sha256')
+export declare function sha256(data: Uint8Array): Uint8Array;

package/runtime/events/NetEvent.ts

@@ -13,10 +13,6 @@ export abstract class NetEvent {
         return this.data.bufferLength();
     }
 
-    public getEventDataSelector(): u64 {
-        return this.data.getSelectorDataType();
-    }
-
     public getEventData(): Uint8Array {
         if (this.data.bufferLength() > MAX_EVENT_DATA_SIZE) {
             throw new Error('Event data length exceeds maximum length.');

package/runtime/events/predefined/ApproveEvent.ts

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

package/runtime/events/predefined/BurnEvent.ts

@@ -5,7 +5,7 @@ import { BytesWriter } from '../../buffer/BytesWriter';
 @final
 export class BurnEvent extends NetEvent {
     constructor(amount: u256) {
-        const data: BytesWriter = new BytesWriter(1, true);
+        const data: BytesWriter = new BytesWriter(32);
         data.writeU256(amount);
 
         super('Burn', data);

package/runtime/events/predefined/ClaimEvent.ts

@@ -5,7 +5,7 @@ import { BytesWriter } from '../../buffer/BytesWriter';
 @final
 export class ClaimEvent extends NetEvent {
     constructor(amount: u256) {
-        const data: BytesWriter = new BytesWriter(1, true);
+        const data: BytesWriter = new BytesWriter(32);
         data.writeU256(amount);
 
         super('Claim', data);

package/runtime/events/predefined/MintEvent.ts

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

package/runtime/events/predefined/StakeEvent.ts

@@ -5,7 +5,7 @@ import { BytesWriter } from '../../buffer/BytesWriter';
 @final
 export class StakeEvent extends NetEvent {
     constructor(amount: u256) {
-        const data: BytesWriter = new BytesWriter(1, true);
+        const data: BytesWriter = new BytesWriter(32);
         data.writeU256(amount);
 
         super('Stake', data);

package/runtime/events/predefined/TransferEvent.ts

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

package/runtime/events/predefined/UnstakeEvent.ts

@@ -5,7 +5,7 @@ import { BytesWriter } from '../../buffer/BytesWriter';
 @final
 export class UnstakeEvent extends NetEvent {
     constructor(amount: u256) {
-        const data: BytesWriter = new BytesWriter(1, true);
+        const data: BytesWriter = new BytesWriter(32);
         data.writeU256(amount);
 
         super('Unstake', data);

package/runtime/math/cyrb53.ts

@@ -2,7 +2,7 @@ export function cyrb53(str: string, seed: i32 = 0): i64 {
     let h1: i32 = 0xdeadbeef ^ seed;
     let h2: i32 = 0x41c6ce57 ^ seed;
     for (let i: i32 = 0; i < str.length; i++) {
-        let ch: i32 = str.charCodeAt(i);
+        const ch: i32 = str.charCodeAt(i);
         h1 = (h1 ^ ch) * 2654435761;
         h2 = (h2 ^ ch) * 1597334677;
     }
@@ -32,7 +32,7 @@ export function cyrb53a(str: u8[], seed: i32 = 0): u64 {
     let h2: u64 = u64(0x41c6ce57 ^ seed);
 
     for (let i: i32 = 0; i < str.length; i++) {
-        let ch: u64 = u64(str[i]);
+        const ch: u64 = u64(str[i]);
         h1 = imul64(h1 ^ ch, 0x85ebca77);
         h2 = imul64(h2 ^ ch, 0xc2b2ae3d);
     }
@@ -42,5 +42,7 @@ export function cyrb53a(str: u8[], seed: i32 = 0): u64 {
     h1 ^= h2 >> 16;
     h2 ^= h1 >> 16;
 
+    // We are sure that the result is within the range of u64.
+    // eslint-disable-next-line no-loss-of-precision
     return (2097152 * (h2 & 0xffffffffffffffff) + (h1 >> 11)) & 0xffffffffffffffff;
 }

package/runtime/math/rnd.ts

@@ -7,8 +7,10 @@ let random_seeded = false;
 function murmurHash3(h: u64): u64 {
     // Force all bits of a hash block to avalanche
     h ^= h >> 33; // see: https://github.com/aappleby/smhasher
+    // eslint-disable-next-line no-loss-of-precision
     h *= 0xff51afd7ed558ccd;
     h ^= h >> 33;
+    // eslint-disable-next-line no-loss-of-precision
     h *= 0xc4ceb9fe1a85ec53;
     h ^= h >> 33;
     return h;
@@ -25,6 +27,8 @@ function seedRandom(value: i64): void {
     // Instead zero seed use golden ratio:
     // phi = (1 + sqrt(5)) / 2
     // trunc(2^64 / phi) = 0x9e3779b97f4a7c15
+
+    // eslint-disable-next-line no-loss-of-precision
     if (value == 0) value = 0x9e3779b97f4a7c15;
     random_state0_64 = murmurHash3(value);
     random_state1_64 = murmurHash3(~random_state0_64);
@@ -40,7 +44,7 @@ function seedRandom(value: i64): void {
 export function randomU64(seed: i64): u64 {
     if (!random_seeded) seedRandom(seed);
     let s1 = random_state0_64;
-    let s0 = random_state1_64;
+    const s0 = random_state1_64;
     random_state0_64 = s0;
     s1 ^= s1 << 23;
     s1 ^= s1 >> 17;

package/runtime/shared-libraries/OP20Utils.ts

@@ -1,21 +1,21 @@
-import { Address } from '../types/Address';
-import { u256 } from 'as-bignum/assembly';
-import { BytesWriter } from '../buffer/BytesWriter';
-import { Blockchain } from '../env';
-import { encodeSelector, Selector } from '../math/abi';
-
-export class OP20Utils {
-    public static get BALANCE_OF_SELECTOR(): Selector {
-        return encodeSelector('balanceOf');
-    }
-
-    public static balanceOf(token: Address, owner: Address): u256 {
-        const calldata: BytesWriter = new BytesWriter();
-        calldata.writeSelector(OP20Utils.BALANCE_OF_SELECTOR);
-        calldata.writeAddress(owner);
-
-        const response = Blockchain.call(token, calldata);
-
-        return response.readU256();
-    }
-}
+import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
+import { u256 } from 'as-bignum/assembly';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { Blockchain } from '../env';
+import { encodeSelector, Selector } from '../math/abi';
+
+export class OP20Utils {
+    public static get BALANCE_OF_SELECTOR(): Selector {
+        return encodeSelector('balanceOf');
+    }
+
+    public static balanceOf(token: Address, owner: Address): u256 {
+        const calldata: BytesWriter = new BytesWriter(4 + ADDRESS_BYTE_LENGTH);
+        calldata.writeSelector(OP20Utils.BALANCE_OF_SELECTOR);
+        calldata.writeAddress(owner);
+
+        const response = Blockchain.call(token, calldata);
+
+        return response.readU256();
+    }
+}

package/runtime/shared-libraries/TransferHelper.ts

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

package/runtime/storage/Serializable.ts

@@ -1,79 +1,79 @@
-import { u256 } from 'as-bignum/assembly';
-import { Blockchain } from '../env';
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
-import { BytesWriter } from '../buffer/BytesWriter';
-import { BytesReader } from '../buffer/BytesReader';
-import { Revert } from '../types/Revert';
-
-export abstract class Serializable {
-    protected pointer: u16;
-    protected subPointer:MemorySlotPointer;
-
-    protected constructor(pointer: u16,
-                          subPointer:MemorySlotPointer) {
-        this.pointer = pointer;
-        this.subPointer = subPointer;
-    }
-
-    public abstract get chunkCount(): i32;
-    public abstract writeToBuffer(): BytesWriter;
-    public abstract readFromBuffer(reader: BytesReader): void;
-
-    public load() :void {
-        const chunks: u256[] = [];
-
-        for(let index:i32 = 0; index < this.chunkCount; index++){
-            const chunk: u256 = Blockchain.getStorageAt(this.pointer, u256.add(this.subPointer, u256.fromU32(index)), u256.Zero);
-            chunks.push(chunk);
-        }
-
-        const reader = this.chunksToBytes(chunks);
-
-        this.readFromBuffer(reader);
-    }
-
-    public save(): void {
-        const writer: BytesWriter = this.writeToBuffer();
-
-        const buffer = writer.getBuffer();
-
-        const chunks: u256[] = this.bytesToChunks(buffer);
-
-        for (let index: i32 = 0; index < chunks.length; index++) {
-            Blockchain.setStorageAt(
-                this.pointer,
-                u256.add(this.subPointer, u256.fromU32(index)),
-                chunks[index],
-            );
-        }
-    }
-
-    protected bytesToChunks(buffer: Uint8Array): u256[] {
-        const chunks: u256[] = [];
-
-        for (let index: i32 = 0; index < buffer.byteLength; index += 32) {
-            const chunk = buffer.slice(index, index + 32);
-            chunks.push(u256.fromBytes(chunk, true));
-        }
-
-        return chunks;
-    }
-
-    protected chunksToBytes(chunks: u256[]): BytesReader {
-        if(this.chunkCount >= 67108863) {
-            throw new Revert('Too many chunks received');
-        }
-
-        const buffer: Uint8Array = new Uint8Array(this.chunkCount * 32);
-        let offset: i32 = 0;
-
-        for (let indexChunk: i32 = 0; indexChunk < chunks.length; indexChunk++) {
-            const bytes: u8[] = chunks[indexChunk].toBytes(true);
-            for (let indexByte: i32 = 0; indexByte < bytes.length; indexByte++) {
-                buffer[offset++] = bytes[indexByte];
-            }
-        }
-
-        return new BytesReader(buffer);
-    }
-}
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { BytesReader } from '../buffer/BytesReader';
+import { Revert } from '../types/Revert';
+
+export abstract class Serializable {
+    protected pointer: u16;
+    protected subPointer:MemorySlotPointer;
+
+    protected constructor(pointer: u16,
+                          subPointer:MemorySlotPointer) {
+        this.pointer = pointer;
+        this.subPointer = subPointer;
+    }
+
+    public abstract get chunkCount(): i32;
+    public abstract writeToBuffer(): BytesWriter;
+    public abstract readFromBuffer(reader: BytesReader): void;
+
+    public load() :void {
+        const chunks: u256[] = [];
+
+        for(let index:i32 = 0; index < this.chunkCount; index++){
+            const chunk: u256 = Blockchain.getStorageAt(this.pointer, u256.add(this.subPointer, u256.fromU32(index)), u256.Zero);
+            chunks.push(chunk);
+        }
+
+        const reader = this.chunksToBytes(chunks);
+
+        this.readFromBuffer(reader);
+    }
+
+    public save(): void {
+        const writer: BytesWriter = this.writeToBuffer();
+
+        const buffer = writer.getBuffer();
+
+        const chunks: u256[] = this.bytesToChunks(buffer);
+
+        for (let index: i32 = 0; index < chunks.length; index++) {
+            Blockchain.setStorageAt(
+                this.pointer,
+                u256.add(this.subPointer, u256.fromU32(index)),
+                chunks[index],
+            );
+        }
+    }
+
+    protected bytesToChunks(buffer: Uint8Array): u256[] {
+        const chunks: u256[] = [];
+
+        for (let index: i32 = 0; index < buffer.byteLength; index += 32) {
+            const chunk = buffer.slice(index, index + 32);
+            chunks.push(u256.fromBytes(chunk, true));
+        }
+
+        return chunks;
+    }
+
+    protected chunksToBytes(chunks: u256[]): BytesReader {
+        if(this.chunkCount >= 67108863) {
+            throw new Revert('Too many chunks received');
+        }
+
+        const buffer: Uint8Array = new Uint8Array(this.chunkCount * 32);
+        let offset: i32 = 0;
+
+        for (let indexChunk: i32 = 0; indexChunk < chunks.length; indexChunk++) {
+            const bytes: u8[] = chunks[indexChunk].toBytes(true);
+            for (let indexByte: i32 = 0; indexByte < bytes.length; indexByte++) {
+                buffer[offset++] = bytes[indexByte];
+            }
+        }
+
+        return new BytesReader(buffer);
+    }
+}

package/runtime/storage/StoredString.ts

@@ -63,7 +63,7 @@ export class StoredString {
         // Save the remaining chunks in subsequent storage slots
         while (remainingLength > 0) {
             bytesToWrite = this.min(remainingLength, 32);
-            let storageValue: u256 = this.saveChunk(
+            const storageValue: u256 = this.saveChunk(
                 u256.Zero,
                 this._value,
                 offset,
@@ -86,9 +86,9 @@ export class StoredString {
         length: u32,
         storageOffset: u32,
     ): u256 {
-        let bytes = storage.toBytes(true);
+        const bytes = storage.toBytes(true);
         for (let i: u32 = 0; i < length; i++) {
-            let index: i32 = i32(offset + i);
+            const index: i32 = i32(offset + i);
             bytes[i + storageOffset] = u8(value.charCodeAt(index));
         }
         return u256.fromBytes(bytes, true);
@@ -113,7 +113,7 @@ export class StoredString {
         let remainingLength: u32 = length;
         let currentStorage: u256 = header;
 
-        let bytesToRead: u32 = this.min(remainingLength, 28);
+        const bytesToRead: u32 = this.min(remainingLength, 28);
         let str: string = this.loadChunk(currentStorage, 4, bytesToRead);
         remainingLength -= bytesToRead;
 
@@ -123,7 +123,7 @@ export class StoredString {
             currentStorage = Blockchain.getStorageAt(this.pointer, currentPointer, u256.Zero);
 
             // Extract the relevant portion of the string from the current storage slot
-            let bytesToRead: u32 = this.min(remainingLength, 32);
+            const bytesToRead: u32 = this.min(remainingLength, 32);
             str += this.loadChunk(currentStorage, 0, bytesToRead);
 
             remainingLength -= bytesToRead;