@btc-vision/btc-runtime 1.0.9 → 1.0.11

package/package.json

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

package/runtime/contracts/OP_20.ts

@@ -36,28 +36,16 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
 
         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,
-        );
+        const supply: u256 = Blockchain.getStorageAt(supplyPointer, u256.Zero, u256.Zero);
+        this._totalSupply = new StoredU256(supplyPointer, u256.Zero, supply);
     }
 
     public _totalSupply: StoredU256;

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 { deploy, deployFromAddress, loadPointer, 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;
@@ -115,14 +111,10 @@ export class BlockchainEnvironment {
     }
 
     public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
-        if (destinationContract === this._callee) {
+        /*if (destinationContract === this._callee) {
             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);
@@ -135,22 +127,9 @@ export class BlockchainEnvironment {
             throw this.error('external call failed');
         }
 
-        return new BytesReader(response);
-    }
-
-    public getCalls(): Uint8Array {
-        const buffer: BytesWriter = new BytesWriter();
-
-        buffer.writeLimitedAddressBytesMap(this.externalCalls);
-        this.externalCalls.clear();
+        return new BytesReader(response);*/
 
-        return buffer.getBuffer();
-    }
-
-    public loadCallsResponse(responses: Uint8Array): void {
-        const memoryReader: BytesReader = new BytesReader(responses);
-
-        this.externalCallsResponse = memoryReader.readMultiBytesAddressMap();
+        throw this.error('Not implemented');
     }
 
     public addEvent(event: NetEvent): void {
@@ -192,64 +171,62 @@ 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.ensureStorageAtPointer(pointerHash, defaultValue);
 
-        this._internalSetStorageAt(address, pointerHash, value);
+        this._internalSetStorageAt(pointerHash, value);
     }
 
     public getViewSelectors(): Uint8Array {
@@ -264,113 +241,43 @@ 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);
-    }
-
-    private ensureStorageAtAddress(address: Address): void {
-        if (!this.storage.has(address)) {
-            this.storage.set(address, new Map<u256, MemorySlotData<u256>>());
+        if (u256.eq(value, u256.Zero)) {
+            return;
         }
+
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeU256(pointerHash);
+        writer.writeU256(value);
+
+        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 +287,25 @@ 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);
-
-        const storage: PointerStorage = this.storage.get(address);
-        if (!this.hasPointerStorageHash(storage, pointerHash)) {
-            this._internalSetStorageAt(address, pointerHash, defaultValue);
+        if (!this.hasPointerStorageHash(pointerHash)) {
+            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,4 @@ 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;

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, this.defaultValue);
 
         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, this.defaultValue);
 
         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> {
@@ -44,7 +39,7 @@ export class MultiAddressMemoryMap<
     public set(key: K, value: KeyMerger<K, K2, V>): this {
         this.createKeyMerger(key);
 
-        return <this>(<unknown>super.set(key, value));
+        return <this>super.set(key, value);
     }
 
     public has(key: K): bool {
@@ -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/StoredU256.ts

@@ -1,23 +1,16 @@
 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,
-        );
+        this._value = Blockchain.getStorageAt(this.pointer, this.subPointer, this.defaultValue);
     }
 
     private _value: u256 = u256.Zero;
@@ -33,13 +26,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, this.defaultValue);
     }
 
     @inline
@@ -53,13 +40,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, this.defaultValue);
 
         return this;
     }
@@ -70,13 +51,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, this.defaultValue);
 
         return this;
     }
@@ -87,13 +62,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, this.defaultValue);
 
         return this;
     }
@@ -152,13 +121,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, this.defaultValue);
 
         return this;
     }
@@ -169,13 +132,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, this.defaultValue);
 
         return this;
     }
@@ -186,13 +143,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, this.defaultValue);
 
         return this;
     }
@@ -203,13 +154,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, this.defaultValue);
 
         return this;
     }
@@ -231,13 +176,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, this.defaultValue);
 
         return this;
     }
@@ -262,13 +201,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, this.defaultValue);
 
         return this;
     }
@@ -279,13 +212,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, this.defaultValue);
 
         return this;
     }
@@ -296,13 +223,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, this.defaultValue);
 
         return this;
     }
@@ -311,13 +232,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, this.defaultValue);
 
         return this;
     }
@@ -328,11 +243,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);
     }
 }