@btc-vision/btc-runtime 1.0.29 → 1.0.31

package/package.json

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

package/runtime/env/BTCEnvironment.ts

@@ -1,314 +1,319 @@
-import { Address, PotentialAddress } from '../types/Address';
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
-import { MemorySlotData } from '../memory/MemorySlot';
-import { u256 } from 'as-bignum/assembly';
-import { ABIRegistry } from '../universal/ABIRegistry';
-import { BytesReader } from '../buffer/BytesReader';
-import { encodePointerHash } from '../math/abi';
-import { BytesWriter } from '../buffer/BytesWriter';
-import { MAX_EVENTS, NetEvent } from '../events/NetEvent';
-import { Potential } from '../lang/Definitions';
-import { OP_NET } from '../contracts/OP_NET';
-import { PointerStorage } from '../types';
-import {
-    callContract,
-    deploy,
-    deployFromAddress,
-    encodeAddress,
-    loadPointer,
-    log,
-    storePointer,
-} from './global';
-import { DeployContractResponse } from '../interfaces/DeployContractResponse';
-import { MapU256 } from '../generic/MapU256';
-
-export * from '../env/global';
-
-@final
-export class BlockchainEnvironment {
-    private static readonly runtimeException: string = 'RuntimeException';
-
-    private storage: PointerStorage = new MapU256();
-    private events: NetEvent[] = [];
-
-    private _callee: PotentialAddress = null;
-    private _caller: PotentialAddress = null;
-    private currentBlock: u256 = u256.Zero;
-
-    constructor() {}
-
-    private _timestamp: u64 = 0;
-
-    public get timestamp(): u64 {
-        return this._timestamp;
-    }
-
-    private _contract: Potential<() => OP_NET> = null;
-
-    public get contract(): OP_NET {
-        if (!this._contract) {
-            throw this.error('Contract is required');
-        }
-
-        return this._contract();
-    }
-
-    public set contract(contract: () => OP_NET) {
-        this._contract = contract;
-    }
-
-    private _nextPointer: u8 = 0;
-
-    public get nextPointer(): u8 {
-        this._nextPointer += 1;
-
-        return this._nextPointer;
-    }
-
-    public _owner: Potential<Address> = null;
-
-    public get owner(): Address {
-        if (!this._owner) {
-            throw this.error('Owner is required');
-        }
-
-        return this._owner as Address;
-    }
-
-    public _contractAddress: Potential<Address> = null;
-
-    public get contractAddress(): Address {
-        if (!this._contractAddress) {
-            throw this.error('Contract address is required');
-        }
-
-        return this._contractAddress as Address;
-    }
-
-    public get blockNumber(): u256 {
-        return this.currentBlock;
-    }
-
-    public get blockNumberU64(): u64 {
-        return this.currentBlock.toU64();
-    }
-
-    public callee(): Address {
-        if (!this._callee) {
-            throw this.error('Callee is required');
-        }
-
-        return this._callee as Address;
-    }
-
-    public caller(): Address {
-        if (!this._caller) {
-            throw this.error('Caller is required');
-        }
-
-        return this._caller as Address;
-    }
-
-    public setEnvironment(data: Uint8Array): void {
-        const reader: BytesReader = new BytesReader(data);
-
-        this._caller = reader.readAddress();
-        this._callee = reader.readAddress();
-        this.currentBlock = reader.readU256();
-
-        this._owner = reader.readAddress();
-        this._contractAddress = reader.readAddress();
-
-        this._timestamp = reader.readU64();
-    }
-
-    public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
-        if (destinationContract === this._callee) {
-            throw this.error('Cannot call self');
-        }
-
-        if (!destinationContract) {
-            throw this.error('Destination contract is required');
-        }
-
-        const call = new BytesWriter();
-        call.writeAddress(destinationContract);
-        call.writeBytesWithLength(calldata.getBuffer());
-
-        const response: Uint8Array = callContract(call.getBuffer());
-
-        return new BytesReader(response);
-    }
-
-    public log(data: string): void {
-        const writer = new BytesWriter();
-        writer.writeStringWithLength(data);
-
-        const buffer = writer.getBuffer();
-        log(buffer);
-    }
-
-    public addEvent(event: NetEvent): void {
-        if (this.events.length >= i32(MAX_EVENTS)) {
-            throw this.error(`Too many events in the same transaction.`);
-        }
-
-        this.events.push(event);
-    }
-
-    public getEvents(): Uint8Array {
-        const eventLength: u16 = u16(this.events.length);
-        if (eventLength > MAX_EVENTS) {
-            throw this.error('Too many events');
-        }
-
-        const buffer: BytesWriter = new BytesWriter();
-        buffer.writeU16(eventLength);
-
-        for (let i: u8 = 0; i < eventLength; i++) {
-            const event: NetEvent = this.events[i];
-
-            buffer.writeStringWithLength(event.eventType);
-            buffer.writeU64(event.getEventDataSelector());
-            buffer.writeBytesWithLength(event.getEventData());
-        }
-
-        return buffer.getBuffer();
-    }
-
-    public encodeVirtualAddress(virtualAddress: Uint8Array): Address {
-        const writer: BytesWriter = new BytesWriter();
-        writer.writeBytesWithLength(virtualAddress);
-
-        const buffer: Uint8Array = writer.getBuffer();
-        const cb: Potential<Uint8Array> = encodeAddress(buffer);
-        if (!cb) throw this.error('Failed to encode virtual address');
-
-        const reader: BytesReader = new BytesReader(cb as Uint8Array);
-        return reader.readAddress();
-    }
-
-    public deployContract(hash: u256, bytecode: Uint8Array): DeployContractResponse {
-        const writer = new BytesWriter();
-        writer.writeU256(hash);
-        writer.writeBytes(bytecode);
-
-        const cb: Potential<Uint8Array> = deploy(writer.getBuffer());
-        if (!cb) throw this.error('Failed to deploy contract');
-
-        const reader: BytesReader = new BytesReader(cb as Uint8Array);
-        const virtualAddress: u256 = reader.readU256();
-        const contractAddress: Address = reader.readAddress();
-
-        return new DeployContractResponse(virtualAddress, contractAddress);
-    }
-
-    public deployContractFromExisting(
-        existingAddress: Address,
-        salt: u256,
-    ): DeployContractResponse {
-        const writer = new BytesWriter();
-        writer.writeAddress(existingAddress);
-        writer.writeU256(salt);
-
-        const buffer: Uint8Array = writer.getBuffer();
-        const cb: Potential<Uint8Array> = deployFromAddress(buffer);
-        if (!cb) throw this.error('Failed to deploy contract');
-
-        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(
-        pointer: u16,
-        subPointer: MemorySlotPointer,
-        defaultValue: MemorySlotData<u256>,
-    ): MemorySlotData<u256> {
-        const pointerHash: MemorySlotPointer = encodePointerHash(pointer, subPointer);
-        this.ensureStorageAtPointer(pointerHash, defaultValue);
-
-        if (this.storage.has(pointerHash)) {
-            return this.storage.get(pointerHash);
-        }
-
-        return defaultValue;
-    }
-
-    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(pointer, subPointer, u256.Zero);
-
-        return u256.ne(val, u256.Zero);
-    }
-
-    public setStorageAt(
-        pointer: u16,
-        keyPointer: MemorySlotPointer,
-        value: MemorySlotData<u256>,
-    ): void {
-        const pointerHash: u256 = encodePointerHash(pointer, keyPointer);
-
-        this._internalSetStorageAt(pointerHash, value);
-    }
-
-    public getViewSelectors(): Uint8Array {
-        return ABIRegistry.getViewSelectors();
-    }
-
-    public getMethodSelectors(): Uint8Array {
-        return ABIRegistry.getMethodSelectors();
-    }
-
-    public getWriteMethods(): Uint8Array {
-        return ABIRegistry.getWriteMethods();
-    }
-
-    private error(msg: string): Error {
-        return new Error(`${BlockchainEnvironment.runtimeException}: ${msg}`);
-    }
-
-    private _internalSetStorageAt(pointerHash: u256, value: MemorySlotData<u256>): void {
-        this.storage.set(pointerHash, value);
-
-        const writer: BytesWriter = new BytesWriter();
-        writer.writeU256(pointerHash);
-        writer.writeU256(value);
-
-        const buffer: Uint8Array = writer.getBuffer();
-        storePointer(buffer);
-    }
-
-    private hasPointerStorageHash(pointer: MemorySlotPointer): bool {
-        if (this.storage.has(pointer)) {
-            return true;
-        }
-
-        // 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(
-        pointerHash: MemorySlotPointer,
-        defaultValue: MemorySlotData<u256>,
-    ): void {
-        if (!this.hasPointerStorageHash(pointerHash)) {
-            if (u256.eq(defaultValue, u256.Zero)) {
-                return;
-            }
-
-            this._internalSetStorageAt(pointerHash, defaultValue);
-        }
-    }
-}
+import { Address, PotentialAddress } from '../types/Address';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { MemorySlotData } from '../memory/MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+import { ABIRegistry } from '../universal/ABIRegistry';
+import { BytesReader } from '../buffer/BytesReader';
+import { encodePointerHash } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { MAX_EVENTS, NetEvent } from '../events/NetEvent';
+import { Potential } from '../lang/Definitions';
+import { OP_NET } from '../contracts/OP_NET';
+import { PointerStorage } from '../types';
+import {
+    callContract,
+    deploy,
+    deployFromAddress,
+    encodeAddress,
+    loadPointer,
+    log,
+    storePointer,
+} from './global';
+import { DeployContractResponse } from '../interfaces/DeployContractResponse';
+import { MapU256 } from '../generic/MapU256';
+
+export * from '../env/global';
+
+@final
+export class BlockchainEnvironment {
+    private static readonly MAX_U16: u16 = 65535;
+    private static readonly runtimeException: string = 'RuntimeException';
+
+    private storage: PointerStorage = new MapU256();
+    private events: NetEvent[] = [];
+
+    private _callee: PotentialAddress = null;
+    private _caller: PotentialAddress = null;
+    private currentBlock: u256 = u256.Zero;
+
+    constructor() {}
+
+    private _timestamp: u64 = 0;
+
+    public get timestamp(): u64 {
+        return this._timestamp;
+    }
+
+    private _contract: Potential<() => OP_NET> = null;
+
+    public get contract(): OP_NET {
+        if (!this._contract) {
+            throw this.error('Contract is required');
+        }
+
+        return this._contract();
+    }
+
+    public set contract(contract: () => OP_NET) {
+        this._contract = contract;
+    }
+
+    private _nextPointer: u16 = 0;
+
+    public get nextPointer(): u16 {
+        if(this._nextPointer === BlockchainEnvironment.MAX_U16) {
+			throw this.error(`Out of storage pointer.`);
+		}
+
+		this._nextPointer += 1;
+
+        return this._nextPointer;
+    }
+
+    public _owner: Potential<Address> = null;
+
+    public get owner(): Address {
+        if (!this._owner) {
+            throw this.error('Owner is required');
+        }
+
+        return this._owner as Address;
+    }
+
+    public _contractAddress: Potential<Address> = null;
+
+    public get contractAddress(): Address {
+        if (!this._contractAddress) {
+            throw this.error('Contract address is required');
+        }
+
+        return this._contractAddress as Address;
+    }
+
+    public get blockNumber(): u256 {
+        return this.currentBlock;
+    }
+
+    public get blockNumberU64(): u64 {
+        return this.currentBlock.toU64();
+    }
+
+    public callee(): Address {
+        if (!this._callee) {
+            throw this.error('Callee is required');
+        }
+
+        return this._callee as Address;
+    }
+
+    public caller(): Address {
+        if (!this._caller) {
+            throw this.error('Caller is required');
+        }
+
+        return this._caller as Address;
+    }
+
+    public setEnvironment(data: Uint8Array): void {
+        const reader: BytesReader = new BytesReader(data);
+
+        this._caller = reader.readAddress();
+        this._callee = reader.readAddress();
+        this.currentBlock = reader.readU256();
+
+        this._owner = reader.readAddress();
+        this._contractAddress = reader.readAddress();
+
+        this._timestamp = reader.readU64();
+    }
+
+    public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
+        if (destinationContract === this._callee) {
+            throw this.error('Cannot call self');
+        }
+
+        if (!destinationContract) {
+            throw this.error('Destination contract is required');
+        }
+
+        const call = new BytesWriter();
+        call.writeAddress(destinationContract);
+        call.writeBytesWithLength(calldata.getBuffer());
+
+        const response: Uint8Array = callContract(call.getBuffer());
+
+        return new BytesReader(response);
+    }
+
+    public log(data: string): void {
+        const writer = new BytesWriter();
+        writer.writeStringWithLength(data);
+
+        const buffer = writer.getBuffer();
+        log(buffer);
+    }
+
+    public addEvent(event: NetEvent): void {
+        if (this.events.length >= i32(MAX_EVENTS)) {
+            throw this.error(`Too many events in the same transaction.`);
+        }
+
+        this.events.push(event);
+    }
+
+    public getEvents(): Uint8Array {
+        const eventLength: u16 = u16(this.events.length);
+        if (eventLength > MAX_EVENTS) {
+            throw this.error('Too many events');
+        }
+
+        const buffer: BytesWriter = new BytesWriter();
+        buffer.writeU16(eventLength);
+
+        for (let i: u8 = 0; i < eventLength; i++) {
+            const event: NetEvent = this.events[i];
+
+            buffer.writeStringWithLength(event.eventType);
+            buffer.writeU64(event.getEventDataSelector());
+            buffer.writeBytesWithLength(event.getEventData());
+        }
+
+        return buffer.getBuffer();
+    }
+
+    public encodeVirtualAddress(virtualAddress: Uint8Array): Address {
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeBytesWithLength(virtualAddress);
+
+        const buffer: Uint8Array = writer.getBuffer();
+        const cb: Potential<Uint8Array> = encodeAddress(buffer);
+        if (!cb) throw this.error('Failed to encode virtual address');
+
+        const reader: BytesReader = new BytesReader(cb as Uint8Array);
+        return reader.readAddress();
+    }
+
+    public deployContract(hash: u256, bytecode: Uint8Array): DeployContractResponse {
+        const writer = new BytesWriter();
+        writer.writeU256(hash);
+        writer.writeBytes(bytecode);
+
+        const cb: Potential<Uint8Array> = deploy(writer.getBuffer());
+        if (!cb) throw this.error('Failed to deploy contract');
+
+        const reader: BytesReader = new BytesReader(cb as Uint8Array);
+        const virtualAddress: u256 = reader.readU256();
+        const contractAddress: Address = reader.readAddress();
+
+        return new DeployContractResponse(virtualAddress, contractAddress);
+    }
+
+    public deployContractFromExisting(
+        existingAddress: Address,
+        salt: u256,
+    ): DeployContractResponse {
+        const writer = new BytesWriter();
+        writer.writeAddress(existingAddress);
+        writer.writeU256(salt);
+
+        const buffer: Uint8Array = writer.getBuffer();
+        const cb: Potential<Uint8Array> = deployFromAddress(buffer);
+        if (!cb) throw this.error('Failed to deploy contract');
+
+        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(
+        pointer: u16,
+        subPointer: MemorySlotPointer,
+        defaultValue: MemorySlotData<u256>,
+    ): MemorySlotData<u256> {
+        const pointerHash: MemorySlotPointer = encodePointerHash(pointer, subPointer);
+        this.ensureStorageAtPointer(pointerHash, defaultValue);
+
+        if (this.storage.has(pointerHash)) {
+            return this.storage.get(pointerHash);
+        }
+
+        return defaultValue;
+    }
+
+    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(pointer, subPointer, u256.Zero);
+
+        return u256.ne(val, u256.Zero);
+    }
+
+    public setStorageAt(
+        pointer: u16,
+        keyPointer: MemorySlotPointer,
+        value: MemorySlotData<u256>,
+    ): void {
+        const pointerHash: u256 = encodePointerHash(pointer, keyPointer);
+
+        this._internalSetStorageAt(pointerHash, value);
+    }
+
+    public getViewSelectors(): Uint8Array {
+        return ABIRegistry.getViewSelectors();
+    }
+
+    public getMethodSelectors(): Uint8Array {
+        return ABIRegistry.getMethodSelectors();
+    }
+
+    public getWriteMethods(): Uint8Array {
+        return ABIRegistry.getWriteMethods();
+    }
+
+    private error(msg: string): Error {
+        return new Error(`${BlockchainEnvironment.runtimeException}: ${msg}`);
+    }
+
+    private _internalSetStorageAt(pointerHash: u256, value: MemorySlotData<u256>): void {
+        this.storage.set(pointerHash, value);
+
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeU256(pointerHash);
+        writer.writeU256(value);
+
+        const buffer: Uint8Array = writer.getBuffer();
+        storePointer(buffer);
+    }
+
+    private hasPointerStorageHash(pointer: MemorySlotPointer): bool {
+        if (this.storage.has(pointer)) {
+            return true;
+        }
+
+        // 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(
+        pointerHash: MemorySlotPointer,
+        defaultValue: MemorySlotData<u256>,
+    ): void {
+        if (!this.hasPointerStorageHash(pointerHash)) {
+            if (u256.eq(defaultValue, u256.Zero)) {
+                return;
+            }
+
+            this._internalSetStorageAt(pointerHash, defaultValue);
+        }
+    }
+}

package/runtime/index.ts

@@ -1,52 +1,54 @@
-/** Environment */
-export * from './env';
-
-/** Contracts */
-export * from './contracts/interfaces/IOP_20';
-export * from './contracts/OP_20';
-export * from './contracts/OP_NET';
-
-/** Buffer */
-export * from './buffer/BytesReader';
-export * from './buffer/BytesWriter';
-
-/** Interfaces */
-export * from './interfaces/DeployContractResponse';
-
-/** Events */
-export * from './events/NetEvent';
-export * from './events/predefined';
-
-/** Types */
-export * from './generic/Map';
-export * from './interfaces/IBTC';
-
-/** Definitions */
-export * from './lang/Definitions';
-export * from './types/Address';
-export * from './types/Revert';
-export * from './types/SafeMath';
-
-/** Math */
-export * from './math/abi';
-export * from './math/bytes';
-export * from './math/cyrb53';
-export * from './math/sha256';
-export * from './math/rnd';
-
-/** Memory */
-export * from './memory/AddressMemoryMap';
-export * from './memory/MemorySlot';
-export * from './memory/MemorySlotPointer';
-export * from './memory/KeyMerger';
-export * from './memory/MultiAddressMemoryMap';
-
-/** Storage */
-export * from './storage/StoredU256';
-export * from './storage/StoredString';
-
-/** Universal */
-export * from './universal/ABIRegistry';
-
-/** Shared libraries */
-export * from './shared-libraries/TransferHelper';
+/** Environment */
+export * from './env';
+
+/** Contracts */
+export * from './contracts/interfaces/IOP_20';
+export * from './contracts/OP_20';
+export * from './contracts/OP_NET';
+
+/** Buffer */
+export * from './buffer/BytesReader';
+export * from './buffer/BytesWriter';
+
+/** Interfaces */
+export * from './interfaces/DeployContractResponse';
+
+/** Events */
+export * from './events/NetEvent';
+export * from './events/predefined';
+
+/** Types */
+export * from './generic/Map';
+export * from './interfaces/IBTC';
+
+/** Definitions */
+export * from './lang/Definitions';
+export * from './types/Address';
+export * from './types/Revert';
+export * from './types/SafeMath';
+
+/** Math */
+export * from './math/abi';
+export * from './math/bytes';
+export * from './math/cyrb53';
+export * from './math/sha256';
+export * from './math/rnd';
+
+/** Memory */
+export * from './memory/AddressMemoryMap';
+export * from './memory/MemorySlot';
+export * from './memory/MemorySlotPointer';
+export * from './memory/KeyMerger';
+export * from './memory/MultiAddressMemoryMap';
+
+/** Storage */
+export * from './storage/StoredU256';
+export * from './storage/StoredString';
+export * from './storage/Serializable';
+
+/** Universal */
+export * from './universal/ABIRegistry';
+
+/** Shared libraries */
+export * from './shared-libraries/TransferHelper';
+export * from './shared-libraries/OP20Utils';

package/runtime/shared-libraries/OP20Utils.ts

@@ -0,0 +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();
+    }
+}

package/runtime/storage/Serializable.ts

@@ -0,0 +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);
+    }
+}