@btc-vision/btc-runtime 1.0.10 → 1.0.13

package/README.md

@@ -11,8 +11,8 @@
 
 ## Introduction
 
-The OPNet Smart Contract Runtime is a WebAssembly runtime that is designed to help developers write smart contracts for the OPNet blockchain.
-The runtime is written in AssemblyScript, a subset of TypeScript that compiles to WebAssembly.
+The OPNet Smart Contract Runtime contains all the necessary components to effectively create smart contracts for Bitcoin
+L1. The runtime is written in AssemblyScript.
 
 ### Installation
 

package/package.json

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

package/runtime/contracts/OP_20.ts

@@ -23,41 +23,28 @@ const transferSelector = encodeSelector('transfer');
 const transferFromSelector = encodeSelector('transferFrom');
 
 export abstract class OP_20 extends OP_NET implements IOP_20 {
-    public readonly decimals: u8 = 8;
-
-    public readonly name: string = `OP_20`;
-    public readonly symbol: string = `OP`;
-
     protected readonly allowanceMap: MultiAddressMemoryMap<Address, Address, MemorySlotData<u256>>;
     protected readonly balanceOfMap: AddressMemoryMap<Address, MemorySlotData<u256>>;
 
-    protected constructor(public readonly maxSupply: u256) {
+    protected constructor(
+        protected readonly maxSupply: u256,
+        protected readonly decimals: u8,
+        protected readonly name: string,
+        protected readonly symbol: string,
+    ) {
         super();
 
         this.allowanceMap = new MultiAddressMemoryMap<Address, Address, MemorySlotData<u256>>(
             Blockchain.nextPointer,
-            Blockchain.contractAddress,
             u256.Zero,
         );
+
         this.balanceOfMap = new AddressMemoryMap<Address, MemorySlotData<u256>>(
             Blockchain.nextPointer,
-            Blockchain.contractAddress,
             u256.Zero,
         );
 
-        const supplyPointer = Blockchain.nextPointer;
-        const supply: u256 = Blockchain.getStorageAt(
-            Blockchain.contractAddress,
-            supplyPointer,
-            u256.Zero,
-            u256.Zero,
-        );
-        this._totalSupply = new StoredU256(
-            Blockchain.contractAddress,
-            supplyPointer,
-            u256.Zero,
-            supply,
-        );
+        this._totalSupply = new StoredU256(Blockchain.nextPointer, u256.Zero, u256.Zero);
     }
 
     public _totalSupply: StoredU256;
@@ -168,10 +155,10 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
                 response.writeU8(this.decimals);
                 break;
             case encodeSelector('name'):
-                response.writeString(this.name);
+                response.writeStringWithLength(this.name);
                 break;
             case encodeSelector('symbol'):
-                response.writeString(this.symbol);
+                response.writeStringWithLength(this.symbol);
                 break;
             case encodeSelector('totalSupply'):
                 response.writeU256(this.totalSupply);
@@ -241,9 +228,7 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
         const caller = Blockchain.caller();
 
         if (onlyOwner) this.onlyOwner(callee);
-
         if (caller !== callee) throw new Revert(`callee != caller`);
-        if (callee !== this.owner) throw new Revert('Only indexers can mint tokens');
 
         if (!this.balanceOfMap.has(to)) {
             this.balanceOfMap.set(to, value);
@@ -283,14 +268,10 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
         const newBalance: u256 = SafeMath.sub(balance, value);
         this.balanceOfMap.set(caller, newBalance);
 
-        if (!this.balanceOfMap.has(to)) {
-            this.balanceOfMap.set(to, value);
-        } else {
-            const toBalance: u256 = this.balanceOfMap.get(to);
-            const newToBalance: u256 = SafeMath.add(toBalance, value);
+        const toBalance: u256 = this.balanceOfMap.get(to);
+        const newToBalance: u256 = SafeMath.add(toBalance, value);
 
-            this.balanceOfMap.set(to, newToBalance);
-        }
+        this.balanceOfMap.set(to, newToBalance);
 
         this.createTransferEvent(caller, to, value);
 
@@ -357,19 +338,19 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
         this.emitEvent(burnEvent);
     }
 
-    private createApproveEvent(owner: Address, spender: Address, value: u256): void {
+    protected createApproveEvent(owner: Address, spender: Address, value: u256): void {
         const approveEvent = new ApproveEvent(owner, spender, value);
 
         this.emitEvent(approveEvent);
     }
 
-    private createMintEvent(owner: Address, value: u256): void {
+    protected createMintEvent(owner: Address, value: u256): void {
         const mintEvent = new MintEvent(owner, value);
 
         this.emitEvent(mintEvent);
     }
 
-    private createTransferEvent(from: Address, to: Address, value: u256): void {
+    protected createTransferEvent(from: Address, to: Address, value: u256): void {
         const transferEvent = new TransferEvent(from, to, value);
 
         this.emitEvent(transferEvent);

package/runtime/contracts/interfaces/IOP_20.ts

@@ -3,10 +3,6 @@ import { Calldata } from '../../universal/ABIRegistry';
 import { StoredU256 } from '../../storage/StoredU256';
 
 export interface IOP_20 {
-    readonly name: string;
-    readonly symbol: string;
-
-    readonly decimals: u8;
     readonly _totalSupply: StoredU256;
 
     balanceOf(callData: Calldata): BytesWriter;

package/runtime/env/BTCEnvironment.ts

@@ -10,8 +10,9 @@ import { MAX_EVENTS, NetEvent } from '../events/NetEvent';
 import { Potential } from '../lang/Definitions';
 import { Map } from '../generic/Map';
 import { OP_NET } from '../contracts/OP_NET';
-import { BlockchainStorage, PointerStorage } from '../types';
-import { deploy, deployFromAddress } from './global';
+import { PointerStorage } from '../types';
+import { callContract, deploy, deployFromAddress, loadPointer, log, storePointer } from './global';
+import { DeployContractResponse } from '../interfaces/DeployContractResponse';
 
 export * from '../env/global';
 
@@ -19,12 +20,7 @@ export * from '../env/global';
 export class BlockchainEnvironment {
     private static readonly runtimeException: string = 'RuntimeException';
 
-    private storage: BlockchainStorage = new Map();
-    private initializedStorage: BlockchainStorage = new Map();
-
-    private externalCalls: Map<Address, Uint8Array[]> = new Map();
-    private externalCallsResponse: Map<Address, Uint8Array[]> = new Map();
-
+    private storage: PointerStorage = new Map();
     private events: NetEvent[] = [];
 
     private _callee: PotentialAddress = null;
@@ -119,38 +115,21 @@ export class BlockchainEnvironment {
             throw this.error('Cannot call self');
         }
 
-        if (!this.externalCalls.has(destinationContract)) {
-            this.externalCalls.set(destinationContract, []);
-        }
-
-        const externalCalls = this.externalCalls.get(destinationContract);
-        const buffer = calldata.getBuffer();
-        externalCalls.push(buffer);
+        const call = new BytesWriter();
+        call.writeAddress(destinationContract);
+        call.writeBytesWithLength(calldata.getBuffer());
 
-        const response: Potential<Uint8Array> = this.getExternalCallResponse(
-            destinationContract,
-            externalCalls.length - 1,
-        );
-        if (!response) {
-            throw this.error('external call failed');
-        }
+        const response: Uint8Array = callContract(call.getBuffer());
 
         return new BytesReader(response);
     }
 
-    public getCalls(): Uint8Array {
-        const buffer: BytesWriter = new BytesWriter();
-
-        buffer.writeLimitedAddressBytesMap(this.externalCalls);
-        this.externalCalls.clear();
-
-        return buffer.getBuffer();
-    }
-
-    public loadCallsResponse(responses: Uint8Array): void {
-        const memoryReader: BytesReader = new BytesReader(responses);
+    public log(data: string): void {
+        const writer = new BytesWriter();
+        writer.writeStringWithLength(data);
 
-        this.externalCallsResponse = memoryReader.readMultiBytesAddressMap();
+        const buffer = writer.getBuffer();
+        log(buffer);
     }
 
     public addEvent(event: NetEvent): void {
@@ -192,64 +171,60 @@ export class BlockchainEnvironment {
         return new BytesReader(cb as Uint8Array);
     }
 
-    public deployContractFromExisting(hash: u256, existingAddress: Address): BytesReader {
+    public deployContractFromExisting(
+        existingAddress: Address,
+        salt: u256,
+    ): DeployContractResponse {
         const writer = new BytesWriter();
-        writer.writeU256(hash);
         writer.writeAddress(existingAddress);
+        writer.writeU256(salt);
 
-        const cb: Potential<Uint8Array> = deployFromAddress(writer.getBuffer());
+        const buffer: Uint8Array = writer.getBuffer();
+        const cb: Potential<Uint8Array> = deployFromAddress(buffer);
         if (!cb) throw this.error('Failed to deploy contract');
 
-        return new BytesReader(cb as Uint8Array);
+        const reader: BytesReader = new BytesReader(cb as Uint8Array);
+        const virtualAddress: u256 = reader.readU256();
+        const contractAddress: Address = reader.readAddress();
+
+        return new DeployContractResponse(virtualAddress, contractAddress);
     }
 
     public getStorageAt(
-        address: Address,
         pointer: u16,
         subPointer: MemorySlotPointer,
         defaultValue: MemorySlotData<u256>,
     ): MemorySlotData<u256> {
-        this.ensureStorageAtAddress(address);
-
         const pointerHash: MemorySlotPointer = encodePointerHash(pointer, subPointer);
-        this.ensureStorageAtPointer(address, pointerHash, defaultValue);
-
-        const storage: PointerStorage = this.storage.get(address);
+        this.ensureStorageAtPointer(pointerHash, defaultValue);
 
         // maybe find a better way for this
-        const allKeys: u256[] = storage.keys();
+        const allKeys: u256[] = this.storage.keys();
         for (let i: i32 = 0; i < allKeys.length; i++) {
             const v: u256 = allKeys[i];
 
             if (u256.eq(v, pointerHash)) {
-                return storage.get(v);
+                return this.storage.get(v);
             }
         }
 
         return defaultValue;
     }
 
-    public hasStorageAt(address: Address, pointer: u16, subPointer: MemorySlotPointer): bool {
-        this.ensureStorageAtAddress(address);
-
+    public hasStorageAt(pointer: u16, subPointer: 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(address, pointer, subPointer, u256.Zero);
+        const val: u256 = this.getStorageAt(pointer, subPointer, u256.Zero);
         return val != u256.Zero;
     }
 
     public setStorageAt(
-        address: Address,
         pointer: u16,
         keyPointer: MemorySlotPointer,
         value: MemorySlotData<u256>,
-        defaultValue: MemorySlotData<u256>,
     ): void {
-        this.ensureStorageAtAddress(address);
-
         const pointerHash: u256 = encodePointerHash(pointer, keyPointer);
-        this.ensureStorageAtPointer(address, pointerHash, defaultValue);
 
-        this._internalSetStorageAt(address, pointerHash, value);
+        this._internalSetStorageAt(pointerHash, value);
     }
 
     public getViewSelectors(): Uint8Array {
@@ -264,113 +239,34 @@ export class BlockchainEnvironment {
         return ABIRegistry.getWriteMethods();
     }
 
-    public loadStorage(data: Uint8Array): void {
-        this.purgeMemory();
-
-        const memoryReader: BytesReader = new BytesReader(data);
-        const contractsSize: u32 = memoryReader.readU32();
-
-        for (let i: u32 = 0; i < contractsSize; i++) {
-            const address: Address = memoryReader.readAddress();
-            const storageSize: u32 = memoryReader.readU32();
-
-            this.ensureStorageAtAddress(address);
-            const storage: PointerStorage = this.storage.get(address);
-
-            for (let j: u32 = 0; j < storageSize; j++) {
-                const keyPointer: MemorySlotPointer = memoryReader.readU256();
-                const value: MemorySlotData<u256> = memoryReader.readU256();
-
-                storage.set(keyPointer, value);
-            }
-        }
-    }
-
-    public storageToBytes(): Uint8Array {
-        const memoryWriter: BytesWriter = new BytesWriter();
-        memoryWriter.writeStorage(this.storage);
-
-        //this.storage.clear();
-
-        return memoryWriter.getBuffer();
-    }
-
-    public initializedStorageToBytes(): Uint8Array {
-        const memoryWriter: BytesWriter = new BytesWriter();
-        memoryWriter.writeStorage(this.initializedStorage);
-
-        //this.initializedStorage.clear();
-
-        return memoryWriter.getBuffer();
-    }
-
-    private purgeMemory(): void {
-        this.storage.clear();
-        this.initializedStorage.clear();
-
-        this.events = [];
-
-        this.externalCallsResponse.clear();
-        this.externalCalls.clear();
-    }
-
-    private requireInitialStorage(address: Address, pointerHash: u256, defaultValue: u256): void {
-        if (!this.initializedStorage.has(address)) {
-            this.initializedStorage.set(address, new Map<u256, MemorySlotData<u256>>());
-        }
-
-        //load(pointerHash);
-
-        const storage = this.initializedStorage.get(address);
-        storage.set(pointerHash, defaultValue);
-    }
-
-    private getExternalCallResponse(
-        destinationContract: Address,
-        index: i32,
-    ): Potential<Uint8Array> {
-        if (!this.externalCallsResponse.has(destinationContract)) {
-            this.externalCallsResponse.set(destinationContract, []);
-        }
-
-        const externalCallsResponse = this.externalCallsResponse.get(destinationContract);
-        return externalCallsResponse[index] || null;
-    }
-
     private error(msg: string): Error {
         return new Error(`${BlockchainEnvironment.runtimeException}: ${msg}`);
     }
 
-    private _internalSetStorageAt(
-        address: Address,
-        pointerHash: u256,
-        value: MemorySlotData<u256>,
-    ): void {
-        const storage: PointerStorage = this.storage.get(address);
-        const keys: u256[] = storage.keys();
+    private _internalSetStorageAt(pointerHash: u256, value: MemorySlotData<u256>): void {
+        const keys: u256[] = this.storage.keys();
 
         // Delete the old value, there is a bug with u256 and maps.
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
 
             if (u256.eq(key, pointerHash)) {
-                storage.delete(key);
+                this.storage.delete(key);
             }
         }
 
-        //store(pointerHash, value);
+        this.storage.set(pointerHash, value);
 
-        storage.set(pointerHash, value);
-    }
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeU256(pointerHash);
+        writer.writeU256(value);
 
-    private ensureStorageAtAddress(address: Address): void {
-        if (!this.storage.has(address)) {
-            this.storage.set(address, new Map<u256, MemorySlotData<u256>>());
-        }
+        const buffer: Uint8Array = writer.getBuffer();
+        storePointer(buffer);
     }
 
-    private hasPointerStorageHash(storage: PointerStorage, pointer: MemorySlotPointer): bool {
-        const keys = storage.keys();
+    private hasPointerStorageHash(pointer: MemorySlotPointer): bool {
+        const keys = this.storage.keys();
 
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
@@ -380,24 +276,29 @@ export class BlockchainEnvironment {
             }
         }
 
-        return false;
+        // we attempt to load the requested pointer.
+        const writer = new BytesWriter();
+        writer.writeU256(pointer);
+
+        const result: Uint8Array = loadPointer(writer.getBuffer());
+        const reader: BytesReader = new BytesReader(result);
+
+        const value: u256 = reader.readU256();
+        this.storage.set(pointer, value); // cache the value
+
+        return !u256.eq(value, u256.Zero);
     }
 
     private ensureStorageAtPointer(
-        address: Address,
         pointerHash: MemorySlotPointer,
         defaultValue: MemorySlotData<u256>,
     ): void {
-        if (!this.storage.has(address)) {
-            throw this.error(`Storage slot not found for address ${address}`);
-        }
-
-        // !!! -- IMPORTANT -- !!!. We have to tell the indexer that we need this storage slot to continue even if it's already defined.
-        this.requireInitialStorage(address, pointerHash, defaultValue);
+        if (!this.hasPointerStorageHash(pointerHash)) {
+            if (u256.eq(defaultValue, u256.Zero)) {
+                return;
+            }
 
-        const storage: PointerStorage = this.storage.get(address);
-        if (!this.hasPointerStorageHash(storage, pointerHash)) {
-            this._internalSetStorageAt(address, pointerHash, defaultValue);
+            this._internalSetStorageAt(pointerHash, defaultValue);
         }
     }
 }

package/runtime/env/global.ts

@@ -1,12 +1,10 @@
-import { u256 } from 'as-bignum/assembly/integer/u256';
-
 // @ts-ignore
 @external('env', 'load')
-export declare function load(data: Uint8Array): u256;
+export declare function loadPointer(data: Uint8Array): Uint8Array;
 
 // @ts-ignore
 @external('env', 'store')
-export declare function store(data: Uint8Array): void;
+export declare function storePointer(data: Uint8Array): Uint8Array;
 
 // @ts-ignore
 @external('env', 'deploy')
@@ -18,4 +16,8 @@ export declare function deployFromAddress(data: Uint8Array): Uint8Array;
 
 // @ts-ignore
 @external('env', 'call')
-export declare function call(data: Uint8Array): Uint8Array;
+export declare function callContract(data: Uint8Array): Uint8Array;
+
+// @ts-ignore
+@external('env', 'log')
+export declare function log(data: Uint8Array): void;

package/runtime/exports/index.ts

@@ -32,26 +32,6 @@ export function getWriteMethods(): Uint8Array {
     return Blockchain.getWriteMethods();
 }
 
-export function getModifiedStorage(): Uint8Array {
-    return Blockchain.storageToBytes();
-}
-
-export function initializeStorage(): Uint8Array {
-    return Blockchain.initializedStorageToBytes();
-}
-
-export function loadStorage(data: Uint8Array): void {
-    Blockchain.loadStorage(data);
-}
-
-export function loadCallsResponse(data: Uint8Array): void {
-    Blockchain.loadCallsResponse(data);
-}
-
-export function getCalls(): Uint8Array {
-    return Blockchain.getCalls();
-}
-
 export function setEnvironment(data: Uint8Array): void {
     Blockchain.setEnvironment(data);
 }

package/runtime/index.ts

@@ -10,6 +10,9 @@ export * from './contracts/OP_NET';
 export * from './buffer/BytesReader';
 export * from './buffer/BytesWriter';
 
+/** Interfaces */
+export * from './interfaces/DeployContractResponse';
+
 /** Events */
 export * from './events/NetEvent';
 export * from './events/predefined';

package/runtime/interfaces/DeployContractResponse.ts

@@ -0,0 +1,12 @@
+import { u256 } from 'as-bignum/assembly';
+import { Address } from '../types/Address';
+
+export class DeployContractResponse {
+    readonly virtualAddress: u256;
+    readonly contractAddress: Address;
+
+    constructor(virtualAddress: u256, contractAddress: Address) {
+        this.virtualAddress = virtualAddress;
+        this.contractAddress = contractAddress;
+    }
+}

package/runtime/memory/AddressMemoryMap.ts

@@ -1,6 +1,5 @@
 import { MemorySlotPointer } from './MemorySlotPointer';
 import { Blockchain } from '../env';
-import { Address } from '../types/Address';
 import { encodePointer } from '../math/abi';
 import { MemorySlotData } from './MemorySlot';
 import { u256 } from 'as-bignum/assembly';
@@ -9,45 +8,26 @@ import { u256 } from 'as-bignum/assembly';
 export class AddressMemoryMap<K extends string, V extends MemorySlotData<u256>> {
     public pointer: u16;
 
-    private readonly memoryAllocatorAddress: Address;
-
     constructor(
         pointer: u16,
-        self: Address,
         private readonly defaultValue: V,
     ) {
         this.pointer = pointer;
-        this.memoryAllocatorAddress = self;
     }
 
     public set(key: K, value: V): this {
         const keyHash: MemorySlotPointer = encodePointer(key);
-        Blockchain.setStorageAt(
-            this.memoryAllocatorAddress,
-            this.pointer,
-            keyHash,
-            value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, keyHash, value);
 
         return this;
     }
 
     public get(key: K): MemorySlotData<u256> {
-        return Blockchain.getStorageAt(
-            this.memoryAllocatorAddress,
-            this.pointer,
-            encodePointer(key),
-            this.defaultValue,
-        );
+        return Blockchain.getStorageAt(this.pointer, encodePointer(key), this.defaultValue);
     }
 
     public has(key: K): bool {
-        return Blockchain.hasStorageAt(
-            this.memoryAllocatorAddress,
-            this.pointer,
-            encodePointer(key),
-        );
+        return Blockchain.hasStorageAt(this.pointer, encodePointer(key));
     }
 
     @unsafe

package/runtime/memory/KeyMerger.ts

@@ -1,7 +1,6 @@
 import { MemorySlotData } from './MemorySlot';
 import { u256 } from 'as-bignum/assembly';
 import { Blockchain } from '../env';
-import { Address } from '../types/Address';
 import { MemorySlotPointer } from './MemorySlotPointer';
 import { encodePointer } from '../math/abi';
 
@@ -10,16 +9,13 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
     public parentKey: K;
 
     public pointer: u16;
-    private readonly memoryAllocatorAddress: Address;
 
     constructor(
         parent: K,
         pointer: u16,
-        self: Address,
         private readonly defaultValue: V,
     ) {
         this.pointer = pointer;
-        this.memoryAllocatorAddress = self;
 
         this.parentKey = parent;
     }
@@ -28,13 +24,7 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
         const mergedKey: string = `${this.parentKey}${key2}`;
         const keyHash: MemorySlotPointer = encodePointer(mergedKey);
 
-        Blockchain.setStorageAt(
-            this.memoryAllocatorAddress,
-            this.pointer,
-            keyHash,
-            value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, keyHash, value);
 
         return this;
     }
@@ -42,22 +32,13 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
     public get(key: K): MemorySlotData<u256> {
         const mergedKey: string = `${this.parentKey}${key}`;
 
-        return Blockchain.getStorageAt(
-            this.memoryAllocatorAddress,
-            this.pointer,
-            encodePointer(mergedKey),
-            this.defaultValue,
-        );
+        return Blockchain.getStorageAt(this.pointer, encodePointer(mergedKey), this.defaultValue);
     }
 
     public has(key: K): bool {
         const mergedKey: string = `${this.parentKey}${key}`;
 
-        return Blockchain.hasStorageAt(
-            this.memoryAllocatorAddress,
-            this.pointer,
-            encodePointer(mergedKey),
-        );
+        return Blockchain.hasStorageAt(this.pointer, encodePointer(mergedKey));
     }
 
     @unsafe

package/runtime/memory/MultiAddressMemoryMap.ts

@@ -1,4 +1,3 @@
-import { Address } from '../types/Address';
 import { MemorySlotData } from './MemorySlot';
 import { u256 } from 'as-bignum/assembly';
 import { KeyMerger } from './KeyMerger';
@@ -11,17 +10,13 @@ export class MultiAddressMemoryMap<
 > extends Map<K, KeyMerger<K, K2, V>> {
     public pointer: u16;
 
-    private readonly memoryAllocatorAddress: Address;
-
     constructor(
         pointer: u16,
-        self: Address,
         private readonly defaultValue: V,
     ) {
         super();
 
         this.pointer = pointer;
-        this.memoryAllocatorAddress = self;
     }
 
     public get(key: K): KeyMerger<K, K2, V> {
@@ -61,15 +56,7 @@ export class MultiAddressMemoryMap<
 
     private createKeyMerger(key: K): void {
         if (!super.has(key)) {
-            super.set(
-                key,
-                new KeyMerger<K, K2, V>(
-                    key,
-                    this.pointer,
-                    this.memoryAllocatorAddress,
-                    this.defaultValue,
-                ),
-            );
+            super.set(key, new KeyMerger<K, K2, V>(key, this.pointer, this.defaultValue));
         }
     }
 }

package/runtime/storage/StoredString.ts

@@ -0,0 +1,145 @@
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+import { SafeMath } from '../types/SafeMath';
+
+@final
+export class StoredString {
+    constructor(
+        public pointer: u16,
+        private defaultValue?: string,
+    ) {}
+
+    private _value: string = '';
+
+    @inline
+    public get value(): string {
+        if (!this._value) {
+            this.load();
+        }
+
+        return this._value;
+    }
+
+    @inline
+    public set value(value: string) {
+        this._value = value;
+        this.save();
+    }
+
+    private min(a: u32, b: u32): u32 {
+        return a < b ? a : b;
+    }
+
+    private max(a: u32, b: u32): u32 {
+        return a > b ? a : b;
+    }
+
+    private save(): void {
+        const length: u32 = this._value.length;
+        if (length == 0) {
+            return;
+        }
+
+        if (length > 2048) {
+            throw new Error('StoredString: value is too long');
+        }
+
+        // Prepare the header with the length of the string in the first 4 bytes
+        let header: u256 = u256.fromU32(length);
+        header = SafeMath.shl(header, 224);
+
+        let currentPointer: u256 = u256.Zero;
+        let remainingLength: u32 = length;
+        let offset: u32 = 0;
+
+        // Save the initial chunk (first 28 bytes) in the header
+        let bytesToWrite: u32 = this.min(remainingLength, 28);
+        header = this.saveChunk(header, this._value, offset, bytesToWrite, 4);
+        Blockchain.setStorageAt(this.pointer, currentPointer, header);
+
+        remainingLength -= bytesToWrite;
+        offset += bytesToWrite;
+
+        // Save the remaining chunks in subsequent storage slots
+        while (remainingLength > 0) {
+            bytesToWrite = this.min(remainingLength, 32);
+            let storageValue: u256 = this.saveChunk(
+                u256.Zero,
+                this._value,
+                offset,
+                bytesToWrite,
+                0,
+            );
+            currentPointer = u256.add(currentPointer, u256.One);
+            Blockchain.setStorageAt(this.pointer, currentPointer, storageValue);
+
+            remainingLength -= bytesToWrite;
+            offset += bytesToWrite;
+        }
+    }
+
+    // Helper method to save a chunk of the string into the storage slot
+    private saveChunk(
+        storage: u256,
+        value: string,
+        offset: u32,
+        length: u32,
+        storageOffset: u32,
+    ): u256 {
+        let bytes = storage.toBytes(true);
+        for (let i: u32 = 0; i < length; i++) {
+            let index: i32 = i32(offset + i);
+            bytes[i + storageOffset] = u8(value.charCodeAt(index));
+        }
+        return u256.fromBytes(bytes, true);
+    }
+
+    private load(): void {
+        const header: u256 = Blockchain.getStorageAt(this.pointer, u256.Zero, u256.Zero);
+        if (u256.eq(header, u256.Zero)) {
+            if (this.defaultValue) {
+                this.value = this.defaultValue;
+            }
+
+            return;
+        }
+
+        // the length of the string is stored in the first 4 bytes of the header
+        const bits: u256 = u256.shr(header, 224);
+        const length: u32 = bits.toU32();
+
+        // the rest contains the string itself
+        let currentPointer: u256 = u256.Zero;
+        let remainingLength: u32 = length;
+        let currentStorage: u256 = header;
+
+        let bytesToRead: u32 = this.min(remainingLength, 28);
+        let str: string = this.loadChunk(currentStorage, 4, bytesToRead);
+        remainingLength -= bytesToRead;
+
+        while (remainingLength > 0) {
+            // Move to the next storage slot
+            currentPointer = u256.add(currentPointer, u256.One);
+            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);
+            str += this.loadChunk(currentStorage, 0, bytesToRead);
+
+            remainingLength -= bytesToRead;
+        }
+
+        this._value = str;
+    }
+
+    private loadChunk(value: u256, offset: u32, length: u32): string {
+        const bytes = value.toBytes(true);
+
+        let str: string = '';
+        for (let i: u32 = 0; i < length; i++) {
+            str += String.fromCharCode(bytes[i + offset]);
+        }
+
+        return str;
+    }
+}

package/runtime/storage/StoredU256.ts

@@ -1,24 +1,15 @@
 import { u256 } from 'as-bignum/assembly';
 import { SafeMath } from '../types/SafeMath';
-import { Address } from '../types/Address';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { Blockchain } from '../env';
 
 @final
 export class StoredU256 {
     constructor(
-        public address: Address,
         public pointer: u16,
         public subPointer: MemorySlotPointer,
         private defaultValue: u256,
-    ) {
-        this._value = Blockchain.getStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this.defaultValue,
-        );
-    }
+    ) {}
 
     private _value: u256 = u256.Zero;
 
@@ -33,13 +24,7 @@ export class StoredU256 {
     public set value(value: u256) {
         this._value = value;
 
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
     }
 
     @inline
@@ -53,13 +38,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, value);
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -70,13 +49,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, value);
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -87,13 +60,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.mul(this._value, value);
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -152,13 +119,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.shr(this._value, value);
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -169,13 +130,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.and(this._value, value);
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -186,13 +141,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.or(this._value, value);
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -203,13 +152,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.xor(this._value, value);
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -231,13 +174,7 @@ export class StoredU256 {
             value = u256.shr(value, 1);
         }
 
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -262,13 +199,7 @@ export class StoredU256 {
         }
 
         this._value = result;
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -279,13 +210,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, u256.One);
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -296,13 +221,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, u256.One);
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -311,13 +230,7 @@ export class StoredU256 {
     public set(value: u256): this {
         this._value = value;
 
-        Blockchain.setStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this._value,
-            this.defaultValue,
-        );
+        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
 
         return this;
     }
@@ -328,11 +241,6 @@ export class StoredU256 {
     }
 
     private ensureValue(): void {
-        this._value = Blockchain.getStorageAt(
-            this.address,
-            this.pointer,
-            this.subPointer,
-            this.defaultValue,
-        );
+        this._value = Blockchain.getStorageAt(this.pointer, this.subPointer, this.defaultValue);
     }
 }

package/runtime/types/SafeMath.ts

@@ -64,7 +64,7 @@ export class SafeMath {
         for (let i = shift; i >= 0; i--) {
             if (u256.ge(n, d)) {
                 n = u256.sub(n, d);
-                result = u256.or(result, SafeMath.shl(new u256(1), i));
+                result = u256.or(result, SafeMath.shl(u256.One, i));
             }
             d = u256.shr(d, 1); // restore d to original by shifting right
         }
@@ -86,16 +86,23 @@ export class SafeMath {
         if (u256.gt(y, u256.fromU32(3))) {
             let z = y;
 
-            let x = SafeMath.add(SafeMath.div(y, u256.fromU32(2)), u256.fromU32(1));
+            let u246_2 = u256.fromU32(2);
+
+            let d = SafeMath.div(y, u246_2);
+            let x = SafeMath.add(d, u256.One);
+
             while (u256.lt(x, z)) {
                 z = x;
 
                 let u = SafeMath.div(y, x);
-                x = SafeMath.div(u256.add(u, x), u256.fromU32(2));
+                let y2 = u256.add(u, x);
+
+                x = SafeMath.div(y2, u246_2);
             }
+
             return z;
         } else if (!u256.eq(y, u256.Zero)) {
-            return u256.fromU32(1);
+            return u256.One;
         } else {
             return u256.Zero;
         }