@btc-vision/btc-runtime 1.2.4 → 1.2.6

package/package.json

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

package/runtime/buffer/BytesReader.ts

@@ -1,10 +1,11 @@
 import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { Selector } from '../math/abi';
-import { u256 } from 'as-bignum/assembly';
+import { i128, u128, u256 } from 'as-bignum/assembly';
 import { Revert } from '../types/Revert';
 import { Map } from '../generic/Map';
 import { TransactionInput, TransactionOutput } from '../env/classes/UTXO';
 import { StaticArray } from 'staticarray';
+import { i256 } from '../math/i256';
 
 @final
 export class BytesReader {
@@ -49,12 +50,46 @@ export class BytesReader {
     }
 
     public readU256(): u256 {
+        this.verifyEnd(this.currentOffset + 32);
+
+        const next32Bytes: u8[] = this.readBytesBE(32);
+
+        return u256.fromBytesBE(next32Bytes);
+    }
+
+    @inline
+    public readBytesBE(count: i32): u8[] {
         const next32Bytes: u8[] = [];
-        for (let i = 0; i < 32; i++) {
+        for (let i = 0; i < count; i++) {
             next32Bytes[i] = this.readU8();
         }
 
-        return u256.fromBytesBE(next32Bytes);
+        return next32Bytes;
+    }
+
+    public readI64(): i64 {
+        this.verifyEnd(this.currentOffset + 8);
+
+        const value = this.buffer.getInt64(this.currentOffset, true);
+        this.currentOffset += 8;
+
+        return value;
+    }
+
+    public readU128(): u128 {
+        this.verifyEnd(this.currentOffset + 16);
+
+        const next16Bytes: u8[] = this.readBytesBE(16);
+
+        return u128.fromBytesBE(next16Bytes);
+    }
+
+    public readI128(): i128 {
+        this.verifyEnd(this.currentOffset + 16);
+
+        const next16Bytes: u8[] = this.readBytesBE(16);
+
+        return i128.fromBytesBE(next16Bytes);
     }
 
     public readBytes(length: u32, zeroStop: boolean = false): Uint8Array {
@@ -138,6 +173,14 @@ export class BytesReader {
         return result;
     }
 
+    public readI256(): i256 {
+        this.verifyEnd(this.currentOffset + 32);
+
+        const next32Bytes: u8[] = this.readBytesBE(32);
+
+        return i256.fromBytesBE(next32Bytes);
+    }
+
     public readTuple(): u256[] {
         const length = this.readU32();
         const result: u256[] = new Array<u256>(length);

package/runtime/buffer/BytesWriter.ts

@@ -1,10 +1,11 @@
-import { u256 } from 'as-bignum/assembly';
+import { i128, u128, u256 } from 'as-bignum/assembly';
 import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { Selector } from '../math/abi';
 import { BytesReader } from './BytesReader';
 import { Revert } from '../types/Revert';
 import { Map } from '../generic/Map';
 import { ArrayBuffer } from 'arraybuffer';
+import { i256 } from '../math/i256';
 
 @final
 export class BytesWriter {
@@ -63,6 +64,15 @@ export class BytesWriter {
         this.writeU8(value ? 1 : 0);
     }
 
+    public writeI256(value: i256): void {
+        this.allocSafe(32);
+
+        const bytes = value.toUint8Array(true);
+        for (let i: i32 = 0; i < 32; i++) {
+            this.writeU8(bytes[i] || 0);
+        }
+    }
+
     public writeU256(value: u256): void {
         this.allocSafe(32);
 
@@ -72,6 +82,24 @@ export class BytesWriter {
         }
     }
 
+    public writeI128(value: i128): void {
+        this.allocSafe(32);
+
+        const bytes = value.toUint8Array(true);
+        for (let i: i32 = 0; i < 32; i++) {
+            this.writeU8(bytes[i] || 0);
+        }
+    }
+
+    public writeU128(value: u128): void {
+        this.allocSafe(32);
+
+        const bytes = value.toUint8Array(true);
+        for (let i: i32 = 0; i < 32; i++) {
+            this.writeU8(bytes[i] || 0);
+        }
+    }
+
     public writeTuple(value: u256[]): void {
         this.allocSafe(4 + value.length * 32);
         this.writeU32(u32(value.length));

package/runtime/env/BlockchainEnvironment.ts

@@ -3,7 +3,6 @@ import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { MemorySlotData } from '../memory/MemorySlot';
 import { u256 } from 'as-bignum/assembly';
 import { BytesReader } from '../buffer/BytesReader';
-import { encodePointerHash } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { NetEvent } from '../events/NetEvent';
 import { Potential } from '../lang/Definitions';
@@ -210,11 +209,9 @@ export class BlockchainEnvironment {
     }
 
     public getStorageAt(
-        pointer: u16,
-        subPointer: MemorySlotPointer,
+        pointerHash: MemorySlotPointer,
         defaultValue: MemorySlotData<u256>,
     ): MemorySlotData<u256> {
-        const pointerHash: MemorySlotPointer = encodePointerHash(pointer, subPointer);
         this.ensureStorageAtPointer(pointerHash, defaultValue);
 
         if (this.storage.has(pointerHash)) {
@@ -224,20 +221,14 @@ export class BlockchainEnvironment {
         return defaultValue;
     }
 
-    public hasStorageAt(pointer: u16, subPointer: MemorySlotPointer): bool {
+    public hasStorageAt(pointerHash: 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);
+        const val: u256 = this.getStorageAt(pointerHash, u256.Zero);
 
         return u256.ne(val, u256.Zero);
     }
 
-    public setStorageAt(
-        pointer: u16,
-        keyPointer: MemorySlotPointer,
-        value: MemorySlotData<u256>,
-    ): void {
-        const pointerHash: u256 = encodePointerHash(pointer, keyPointer);
-
+    public setStorageAt(pointerHash: MemorySlotPointer, value: MemorySlotData<u256>): void {
         this._internalSetStorageAt(pointerHash, value);
     }
 

package/runtime/index.ts

@@ -41,6 +41,7 @@ export * from './math/bytes';
 export * from './math/cyrb53';
 export * from './math/sha256';
 export * from './math/rnd';
+export * from './math/i256';
 
 /** Memory */
 export * from './memory/AddressMemoryMap';

package/runtime/math/abi.ts

@@ -1,7 +1,6 @@
 // SO IN TYPESCRIPT, WE CAN NOT USE TWO METHOD WITH THE SAME NAME. SO NOT ADDING THE TYPE TO THE HASH IS A DESIGN CHOICE.
 import { bytes32, bytes4 } from './bytes';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
-import { u256 } from 'as-bignum/assembly';
 import { Sha256 } from './sha256';
 
 export type Selector = u32;
@@ -13,25 +12,8 @@ export function encodeSelector(name: string): Selector {
     return bytes4(hash);
 }
 
-export function encodePointer(str: string): MemorySlotPointer {
-    const typed = Uint8Array.wrap(String.UTF8.encode(str));
+export function encodePointer(typed: Uint8Array): MemorySlotPointer {
     const hash = Sha256.hash(typed);
 
     return bytes32(hash);
 }
-
-export function encodePointerHash(pointer: u16, sub: u256): MemorySlotPointer {
-    const finalBuffer: Uint8Array = new Uint8Array(34);
-    const mergedKey: u8[] = [u8(pointer & u16(0xff)), u8((pointer >> u16(8)) & u16(0xff))];
-
-    for (let i: i32 = 0; i < mergedKey.length; i++) {
-        finalBuffer[i] = mergedKey[i];
-    }
-
-    const subKey = sub.toUint8Array();
-    for (let i: i32 = 0; i < subKey.length; i++) {
-        finalBuffer[mergedKey.length + i] = subKey[i];
-    }
-
-    return bytes32(Sha256.hash(finalBuffer));
-}

package/runtime/math/i256.ts

@@ -0,0 +1,606 @@
+import { i128, u128, u256 } from 'as-bignum/assembly';
+
+export class i256 {
+
+    @inline static get Zero(): i256 { return new i256(); }
+    @inline static get One():  i256 { return new i256(1); }
+    @inline static get Min():  i256 { return new i256(0, 0, 0, 0x8000000000000000); }
+    @inline static get Max():  i256 { return new i256(-1, -1, -1, 0x7FFFFFFFFFFFFFFF); }
+
+    @inline
+    static fromI256(value: i256): i256 {
+        return new i256(value.lo1, value.lo2, value.hi1, value.hi2);
+    }
+
+    @inline
+    static fromU256(value: u256): i256 {
+        return new i256(<i64>value.lo1, <i64>value.lo2, <i64>value.hi1, <i64>value.hi2);
+    }
+
+    @inline
+    static fromI128(value: i128): i256 {
+        var signExt = value.hi >> 63;
+        return new i256(<i64>value.lo, value.hi, signExt, signExt);
+    }
+
+    @inline
+    static fromU128(value: u128): i256 {
+        return new i256(<i64>value.lo, <i64>value.hi, 0, 0);
+    }
+
+    @inline
+    static fromI64(value: i64): i256 {
+        var signExt = value >> 63;
+        return new i256(value, signExt, signExt, signExt);
+    }
+
+    @inline
+    static fromU64(value: u64): i256 {
+        return new i256(<i64>value, 0, 0, 0);
+    }
+
+    @inline
+    static fromI32(value: i32): i256 {
+        var signExt = value >> 31;
+        var signExt64 = <i64>signExt;
+        return new i256(<i64>value, signExt64, signExt64, signExt64);
+    }
+
+    @inline
+    static fromU32(value: u32): i256 {
+        return new i256(<i64>value, 0, 0, 0);
+    }
+
+    @inline
+    static fromF64(value: f64): i256 {
+        var signExt = reinterpret<i64>(value) >> 63;
+        return new i256(<i64>value, signExt, signExt, signExt);
+    }
+
+    @inline
+    static fromF32(value: f32): i256 {
+        var signExt = reinterpret<i32>(value) >> 31;
+        var signExt64 = <i64>signExt;
+        return new i256(<i64>value, signExt64, signExt64, signExt64);
+    }
+
+    @inline
+    static fromBits(
+        l0: i32, l1: i32, l2: i32, l3: i32,
+        h0: i32, h1: i32, h2: i32, h3: i32,
+    ): i256 {
+        return new i256(
+            <i64>l0 | ((<i64>l1) << 32),
+            <i64>l2 | ((<i64>l3) << 32),
+            <i64>h0 | ((<i64>h1) << 32),
+            <i64>h2 | ((<i64>h3) << 32),
+        );
+    }
+
+    @inline
+    static fromBytes<T>(array: T, bigEndian: bool = false): i256 {
+        if (array instanceof u8[]) {
+            return bigEndian
+                ? i256.fromBytesBE(<u8[]>array)
+                : i256.fromBytesLE(<u8[]>array);
+        } else if (array instanceof Uint8Array) {
+            return bigEndian
+                ? i256.fromUint8ArrayBE(<Uint8Array>array)
+                : i256.fromUint8ArrayLE(<Uint8Array>array);
+        } else {
+            throw new TypeError("Unsupported generic type");
+        }
+    }
+
+    @inline
+    static fromBytesLE(array: u8[]): i256 {
+        assert(array.length && (array.length & 31) == 0);
+        var buffer = array.dataStart;
+        return new i256(
+            load<i64>(buffer, 0 * sizeof<i64>()),
+            load<i64>(buffer, 1 * sizeof<i64>()),
+            load<i64>(buffer, 2 * sizeof<i64>()),
+            load<i64>(buffer, 3 * sizeof<i64>()),
+        );
+    }
+
+    @inline
+    static fromBytesBE(array: u8[]): i256 {
+        assert(array.length && (array.length & 31) == 0);
+        var buffer = array.dataStart;
+        return new i256(
+            bswap<i64>(load<i64>(buffer, 3 * sizeof<i64>())),
+            bswap<i64>(load<i64>(buffer, 2 * sizeof<i64>())),
+            bswap<i64>(load<i64>(buffer, 1 * sizeof<i64>())),
+            bswap<i64>(load<i64>(buffer, 0 * sizeof<i64>())),
+        );
+    }
+
+    @inline
+    static fromUint8ArrayLE(array: Uint8Array): i256 {
+        assert(array.length && (array.length & 31) == 0);
+        var buffer = array.dataStart;
+        return new i256(
+            load<i64>(buffer, 0 * sizeof<i64>()),
+            load<i64>(buffer, 1 * sizeof<i64>()),
+            load<i64>(buffer, 2 * sizeof<i64>()),
+            load<i64>(buffer, 3 * sizeof<i64>()),
+        );
+    }
+
+    @inline
+    static fromUint8ArrayBE(array: Uint8Array): i256 {
+        assert(array.length && (array.length & 31) == 0);
+        var buffer = array.dataStart;
+        return new i256(
+            bswap<i64>(load<i64>(buffer, 3 * sizeof<i64>())),
+            bswap<i64>(load<i64>(buffer, 2 * sizeof<i64>())),
+            bswap<i64>(load<i64>(buffer, 1 * sizeof<i64>())),
+            bswap<i64>(load<i64>(buffer, 0 * sizeof<i64>())),
+        );
+    }
+
+    @inline
+    static from<T>(value: T): i256 {
+        if (value instanceof bool) return i256.fromU64(<u64>value);
+        else if (value instanceof i8) return i256.fromI64(<i64>value);
+        else if (value instanceof u8) return i256.fromU64(<u64>value);
+        else if (value instanceof i16) return i256.fromI64(<i64>value);
+        else if (value instanceof u16) return i256.fromU64(<u64>value);
+        else if (value instanceof i32) return i256.fromI32(<i32>value);
+        else if (value instanceof u32) return i256.fromU32(<u32>value);
+        else if (value instanceof i64) return i256.fromI64(<i64>value);
+        else if (value instanceof u64) return i256.fromU64(<u64>value);
+        else if (value instanceof f32) return i256.fromF64(<f64>value);
+        else if (value instanceof f64) return i256.fromF64(<f64>value);
+        else if (value instanceof i128) return i256.fromI128(<i128>value);
+        else if (value instanceof u128) return i256.fromU128(<u128>value);
+        else if (value instanceof i256) return i256.fromI256(<i256>value);
+        else if (value instanceof u256) return i256.fromU256(<u256>value);
+        else if (value instanceof u8[]) return i256.fromBytes(<u8[]>value);
+        else if (value instanceof Uint8Array) return i256.fromBytes(<Uint8Array>value);
+        else throw new TypeError("Unsupported generic type");
+    }
+
+    constructor(
+        public lo1: i64 = 0,
+        public lo2: i64 = 0,
+        public hi1: i64 = 0,
+        public hi2: i64 = 0,
+    ) {}
+
+    @inline
+    set(value: i256): this {
+        this.lo1 = value.lo1;
+        this.lo2 = value.lo2;
+        this.hi1 = value.hi1;
+        this.hi2 = value.hi2;
+        return this;
+    }
+
+    @inline
+    isNeg(): bool {
+        return <bool>(this.hi2 >>> 63);
+    }
+
+    @inline
+    isZero(): bool {
+        return !(this.lo1 | this.lo2 | this.hi1 | this.hi2);
+    }
+
+    @inline @operator.prefix('!')
+    static isEmpty(value: i256): bool {
+        return value.isZero();
+    }
+
+    @operator.prefix('~')
+    not(): i256 {
+        return new i256(~this.lo1, ~this.lo2, ~this.hi1, ~this.hi2);
+    }
+
+    @operator.prefix('+')
+    pos(): i256 {
+        return this;
+    }
+
+    @operator.prefix('-')
+    neg(): i256 {
+        var lo1 = ~this.lo1;
+        var lo2 = ~this.lo2;
+        var hi1 = ~this.hi1;
+        var hi2 = ~this.hi2;
+
+        var lo1p = lo1 + 1;
+        var carry = lo1p == 0 ? 1 : 0;
+
+        var lo2p = lo2 + carry;
+        carry = (lo2p == 0 && carry == 1) ? 1 : 0;
+
+        var hi1p = hi1 + carry;
+        carry = (hi1p == 0 && carry == 1) ? 1 : 0;
+
+        var hi2p = hi2 + carry;
+
+        return new i256(lo1p, lo2p, hi1p, hi2p);
+    }
+
+    @operator('+')
+    static add(a: i256, b: i256): i256 {
+        var lo1 = a.lo1 + b.lo1;
+        var carry = lo1 < a.lo1 ? 1 : 0;
+
+        var lo2 = a.lo2 + b.lo2 + carry;
+        carry = (lo2 < a.lo2 || (carry == 1 && lo2 == a.lo2)) ? 1 : 0;
+
+        var hi1 = a.hi1 + b.hi1 + carry;
+        carry = (hi1 < a.hi1 || (carry == 1 && hi1 == a.hi1)) ? 1 : 0;
+
+        var hi2 = a.hi2 + b.hi2 + carry;
+
+        return new i256(lo1, lo2, hi1, hi2);
+    }
+
+    @operator('-')
+    static sub(a: i256, b: i256): i256 {
+        var lo1 = a.lo1 - b.lo1;
+        var borrow = a.lo1 < b.lo1 ? 1 : 0;
+
+        var lo2 = a.lo2 - b.lo2 - borrow;
+        borrow = a.lo2 < b.lo2 + borrow ? 1 : 0;
+
+        var hi1 = a.hi1 - b.hi1 - borrow;
+        borrow = hi1 < b.hi1 + borrow ? 1 : 0;
+
+        var hi2 = a.hi2 - b.hi2 - borrow;
+
+        return new i256(lo1, lo2, hi1, hi2);
+    }
+
+    @inline @operator('|')
+    static or(a: i256, b: i256): i256 {
+        return new i256(a.lo1 | b.lo1, a.lo2 | b.lo2, a.hi1 | b.hi1, a.hi2 | b.hi2);
+    }
+
+    @inline @operator('^')
+    static xor(a: i256, b: i256): i256 {
+        return new i256(a.lo1 ^ b.lo1, a.lo2 ^ b.lo2, a.hi1 ^ b.hi1, a.hi2 ^ b.hi2);
+    }
+
+    @inline @operator('&')
+    static and(a: i256, b: i256): i256 {
+        return new i256(a.lo1 & b.lo1, a.lo2 & b.lo2, a.hi1 & b.hi1, a.hi2 & b.hi2);
+    }
+
+    @operator('<')
+    static lt(a: i256, b: i256): bool {
+        if (a.hi2 == b.hi2) {
+            if (a.hi1 == b.hi1) {
+                if (a.lo2 == b.lo2) {
+                    return a.lo1 < b.lo1;
+                } else {
+                    return a.lo2 < b.lo2;
+                }
+            } else {
+                return a.hi1 < b.hi1;
+            }
+        } else {
+            return a.hi2 < b.hi2;
+        }
+    }
+
+    @inline @operator('>')
+    static gt(a: i256, b: i256): bool {
+        return b < a;
+    }
+
+    @inline @operator('==')
+    static eq(a: i256, b: i256): bool {
+        return a.lo1 == b.lo1 && a.lo2 == b.lo2 && a.hi1 == b.hi1 && a.hi2 == b.hi2;
+    }
+
+    @inline @operator('!=')
+    static ne(a: i256, b: i256): bool {
+        return !i256.eq(a, b);
+    }
+
+    @inline @operator('<=')
+    static le(a: i256, b: i256): bool {
+        return !i256.gt(a, b);
+    }
+
+    @inline @operator('>=')
+    static ge(a: i256, b: i256): bool {
+        return !i256.lt(a, b);
+    }
+
+    @operator('<<')
+    static shl(value: i256, shift: i32): i256 {
+        shift &= 255;
+        if (shift == 0) return value;
+        if (shift >= 256) return new i256();
+        var lo1 = value.lo1;
+        var lo2 = value.lo2;
+        var hi1 = value.hi1;
+        var hi2 = value.hi2;
+        if (shift >= 192) {
+            let s = shift - 192;
+            return new i256(0, 0, 0, lo1 << s);
+        } else if (shift >= 128) {
+            let s = shift - 128;
+            return new i256(0, 0, lo1 << s, (lo2 << s) | (lo1 >>> (64 - s)));
+        } else if (shift >= 64) {
+            let s = shift - 64;
+            return new i256(0, (lo1 << s), (lo2 << s) | (lo1 >>> (64 - s)), (hi1 << s) | (lo2 >>> (64 - s)));
+        } else {
+            let s = shift;
+            return new i256(
+                lo1 << s,
+                (lo2 << s) | (lo1 >>> (64 - s)),
+                (hi1 << s) | (lo2 >>> (64 - s)),
+                (hi2 << s) | (hi1 >>> (64 - s)),
+            );
+        }
+    }
+
+    @operator('>>')
+    static shr(value: i256, shift: i32): i256 {
+        shift &= 255;
+        if (shift == 0) return value;
+        if (shift >= 256) {
+            let sign = value.isNeg() ? -1 : 0;
+            return new i256(sign, sign, sign, sign);
+        }
+        var lo1 = value.lo1;
+        var lo2 = value.lo2;
+        var hi1 = value.hi1;
+        var hi2 = value.hi2;
+        if (shift >= 192) {
+            let s = shift - 192;
+            let sign = value.isNeg() ? -1 : 0;
+            return new i256((hi2 >> s) | (sign << (64 - s)), sign, sign, sign);
+        } else if (shift >= 128) {
+            let s = shift - 128;
+            return new i256((hi1 >> s) | (hi2 << (64 - s)), (hi2 >> s) | (hi2 >> 63) << (64 - s), hi2 >> 63, hi2 >> 63);
+        } else if (shift >= 64) {
+            let s = shift - 64;
+            return new i256(
+                (lo2 >> s) | (hi1 << (64 - s)),
+                (hi1 >> s) | (hi2 << (64 - s)),
+                (hi2 >> s) | (hi2 >> 63) << (64 - s),
+                hi2 >> 63,
+            );
+        } else {
+            let s = shift;
+            return new i256(
+                (lo1 >> s) | (lo2 << (64 - s)),
+                (lo2 >> s) | (hi1 << (64 - s)),
+                (hi1 >> s) | (hi2 << (64 - s)),
+                (hi2 >> s) | (hi2 >> 63) << (64 - s),
+            );
+        }
+    }
+
+    @operator('>>>')
+    static shr_u(value: i256, shift: i32): i256 {
+        shift &= 255;
+        if (shift == 0) return value;
+        if (shift >= 256) return new i256();
+        var lo1 = value.lo1;
+        var lo2 = value.lo2;
+        var hi1 = value.hi1;
+        var hi2 = value.hi2;
+        if (shift >= 192) {
+            let s = shift - 192;
+            return new i256((hi2 >>> s), 0, 0, 0);
+        } else if (shift >= 128) {
+            let s = shift - 128;
+            return new i256((hi1 >>> s) | (hi2 << (64 - s)), (hi2 >>> s), 0, 0);
+        } else if (shift >= 64) {
+            let s = shift - 64;
+            return new i256(
+                (lo2 >>> s) | (hi1 << (64 - s)),
+                (hi1 >>> s) | (hi2 << (64 - s)),
+                (hi2 >>> s),
+                0,
+            );
+        } else {
+            let s = shift;
+            return new i256(
+                (lo1 >>> s) | (lo2 << (64 - s)),
+                (lo2 >>> s) | (hi1 << (64 - s)),
+                (hi1 >>> s) | (hi2 << (64 - s)),
+                hi2 >>> s,
+            );
+        }
+    }
+
+    clone(): i256 {
+        return new i256(this.lo1, this.lo2, this.hi1, this.hi2);
+    }
+
+    // Helper methods to write the internal representation to a buffer
+    @inline
+    private toArrayBufferLE(buffer: usize): void {
+        store<i64>(buffer, this.lo1, 0 * sizeof<i64>());
+        store<i64>(buffer, this.lo2, 1 * sizeof<i64>());
+        store<i64>(buffer, this.hi1, 2 * sizeof<i64>());
+        store<i64>(buffer, this.hi2, 3 * sizeof<i64>());
+    }
+
+    @inline
+    private toArrayBufferBE(buffer: usize): void {
+        store<i64>(buffer, bswap<i64>(this.hi2), 0 * sizeof<i64>());
+        store<i64>(buffer, bswap<i64>(this.hi1), 1 * sizeof<i64>());
+        store<i64>(buffer, bswap<i64>(this.lo2), 2 * sizeof<i64>());
+        store<i64>(buffer, bswap<i64>(this.lo1), 3 * sizeof<i64>());
+    }
+
+    @inline
+    private toArrayBuffer(buffer: usize, bigEndian: bool = false): void {
+        if (bigEndian) {
+            this.toArrayBufferBE(buffer);
+        } else {
+            this.toArrayBufferLE(buffer);
+        }
+    }
+
+    /**
+     * Convert to Uint8Array
+     * @param bigEndian Little or Big Endian? Default: false
+     * @returns Uint8Array
+     */
+    @inline
+    toUint8Array(bigEndian: bool = false): Uint8Array {
+        var result = new Uint8Array(32);
+        this.toArrayBuffer(result.dataStart, bigEndian);
+        return result;
+    }
+
+    /**
+     * Convert to byte array
+     * @param bigEndian Little or Big Endian? Default: false
+     * @returns Array of bytes
+     */
+    @inline
+    toBytes(bigEndian: bool = false): u8[] {
+        var result = new Array<u8>(32);
+        this.toArrayBuffer(result.dataStart, bigEndian);
+        return result;
+    }
+
+    /**
+     * Convert to StaticArray of bytes
+     * @param bigEndian Little or Big Endian? Default: false
+     * @returns StaticArray<u8>
+     */
+    @inline
+    toStaticBytes(bigEndian: bool = false): StaticArray<u8> {
+        var result = new StaticArray<u8>(32);
+        this.toArrayBuffer(changetype<usize>(result), bigEndian);
+        return result;
+    }
+
+    // Other conversion methods can be added as needed, following similar patterns.
+
+    /**
+     * Generic type conversion
+     */
+    @inline
+    as<T>(): T {
+        var dummy!: T;
+        if (dummy instanceof bool) return <T>this.toBool();
+        else if (dummy instanceof i8) return <T>this.toI64();
+        else if (dummy instanceof u8) return <T>this.toU64();
+        else if (dummy instanceof i16) return <T>this.toI64();
+        else if (dummy instanceof u16) return <T>this.toU64();
+        else if (dummy instanceof i32) return <T>this.toI64();
+        else if (dummy instanceof u32) return <T>this.toU64();
+        else if (dummy instanceof i64) return <T>this.toI64();
+        else if (dummy instanceof u64) return <T>this.toU64();
+        else if (dummy instanceof i128) return <T>this.toI128();
+        else if (dummy instanceof u128) return <T>this.toU128();
+        else if (dummy instanceof i256) return <T>this;
+        else if (dummy instanceof u256) return <T>this.toU256();
+        else if (dummy instanceof u8[]) return <T>this.toBytes();
+        else if (dummy instanceof Uint8Array) return <T>this.toUint8Array();
+        else if (dummy instanceof StaticArray<u8>) return <T>this.toStaticBytes();
+        else if (dummy instanceof String) return <T>this.toString();
+        else throw new TypeError('Unsupported generic type');
+    }
+
+    @inline
+    toBool(): bool {
+        return this.lo1 != 0 || this.lo2 != 0 || this.hi1 != 0 || this.hi2 != 0;
+    }
+
+    @inline
+    toI64(): i64 {
+        return this.lo1;
+    }
+
+    @inline
+    toU64(): u64 {
+        return <u64>this.lo1;
+    }
+
+    @inline
+    toI32(): i32 {
+        return <i32>this.lo1;
+    }
+
+    @inline
+    toU32(): u32 {
+        return <u32>this.lo1;
+    }
+
+    @inline
+    toI128(): i128 {
+        return new i128(<u64>this.lo1, this.lo2);
+    }
+
+    @inline
+    toU128(): u128 {
+        return new u128(<u64>this.lo1, <u64>this.lo2);
+    }
+
+    @inline
+    toU256(): u256 {
+        return new u256(<u64>this.lo1, <u64>this.lo2, <u64>this.hi1, <u64>this.hi2);
+    }
+
+    @inline
+    public toString(radix: i32 = 10): string {
+        assert(radix == 10 || radix == 16, 'radix argument must be 10 or 16');
+        if (this.isZero()) return '0';
+
+        const isNegative = this.isNeg();
+        const value = isNegative ? this.neg() : this.clone();
+        let result = '';
+
+        if (radix == 16) {
+            const HEX_CHARS = '0123456789abcdef';
+            let shift: i32 = 252 - (i256.clz(value) & ~3);
+            let started = false;
+            while (shift >= 0) {
+                let digit = (<u8>((value.shr_u(shift)).lo1 & 0xF));
+                if (digit != 0 || started) {
+                    // @ts-ignore
+                    result += HEX_CHARS.charAt(digit);
+                    started = true;
+                }
+                shift -= 4;
+            }
+            if (isNegative) {
+                result = '-' + result;
+            }
+            return result;
+        } else {
+            // Radix 10 conversion requires division, which needs to be implemented.
+            // Placeholder implementation (throws an error).
+            throw new Error('Radix 10 conversion is not implemented yet.');
+        }
+    }
+
+    shr_u(value: i32): i256 {
+        return i256.shr_u(this, value);
+    }
+
+    @inline
+    static clz(value: i256): i32 {
+        // For signed integers, leading zeros are counted from the sign bit.
+        // If the value is negative, we take its two's complement to get the magnitude.
+        if (value.isNeg()) {
+            value = value.neg();
+        }
+        if (value.hi2 != 0) {
+            return clz<u64>(value.hi2);
+        } else if (value.hi1 != 0) {
+            return clz<u64>(value.hi1) + 64;
+        } else if (value.lo2 != 0) {
+            return clz<u64>(value.lo2) + 128;
+        } else {
+            return clz<u64>(value.lo1) + 192;
+        }
+    }
+
+}

package/runtime/memory/AddressMemoryMap.ts

@@ -3,6 +3,7 @@ import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
 import { MemorySlotData } from './MemorySlot';
 import { u256 } from 'as-bignum/assembly';
+import { BytesWriter } from '../buffer/BytesWriter';
 
 @final
 export class AddressMemoryMap<K extends string, V extends MemorySlotData<u256>> {
@@ -16,18 +17,22 @@ export class AddressMemoryMap<K extends string, V extends MemorySlotData<u256>>
     }
 
     public set(key: K, value: V): this {
-        const keyHash: MemorySlotPointer = encodePointer(key);
-        Blockchain.setStorageAt(this.pointer, keyHash, value);
+        const keyHash: MemorySlotPointer = this.encodePointer(key);
+        Blockchain.setStorageAt(keyHash, value);
 
         return this;
     }
 
     public get(key: K): MemorySlotData<u256> {
-        return Blockchain.getStorageAt(this.pointer, encodePointer(key), this.defaultValue);
+        const keyHash: MemorySlotPointer = this.encodePointer(key);
+
+        return Blockchain.getStorageAt(keyHash, this.defaultValue);
     }
 
     public has(key: K): bool {
-        return Blockchain.hasStorageAt(this.pointer, encodePointer(key));
+        const keyHash: MemorySlotPointer = this.encodePointer(key);
+
+        return Blockchain.hasStorageAt(keyHash);
     }
 
     @unsafe
@@ -41,4 +46,12 @@ export class AddressMemoryMap<K extends string, V extends MemorySlotData<u256>>
     public clear(): void {
         throw new Error('Method not implemented.');
     }
+
+    private encodePointer(key: K): MemorySlotPointer {
+        const writer = new BytesWriter(key.length + 2);
+        writer.writeU16(this.pointer);
+        writer.writeString(key);
+
+        return encodePointer(writer.getBuffer());
+    }
 }

package/runtime/memory/KeyMerger.ts

@@ -3,6 +3,7 @@ import { u256 } from 'as-bignum/assembly';
 import { Blockchain } from '../env';
 import { MemorySlotPointer } from './MemorySlotPointer';
 import { encodePointer } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
 
 @final
 export class KeyMerger<K extends string, K2 extends string, V extends MemorySlotData<u256>> {
@@ -22,9 +23,9 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
 
     public set(key2: K2, value: V): this {
         const mergedKey: string = `${this.parentKey}${key2}`;
-        const keyHash: MemorySlotPointer = encodePointer(mergedKey);
+        const keyHash: MemorySlotPointer = this.encodePointer(mergedKey);
 
-        Blockchain.setStorageAt(this.pointer, keyHash, value);
+        Blockchain.setStorageAt(keyHash, value);
 
         return this;
     }
@@ -32,13 +33,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.pointer, encodePointer(mergedKey), this.defaultValue);
+        return Blockchain.getStorageAt(this.encodePointer(mergedKey), this.defaultValue);
     }
 
     public has(key: K): bool {
         const mergedKey: string = `${this.parentKey}${key}`;
 
-        return Blockchain.hasStorageAt(this.pointer, encodePointer(mergedKey));
+        return Blockchain.hasStorageAt(this.encodePointer(mergedKey));
     }
 
     @unsafe
@@ -50,4 +51,12 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
     public clear(): void {
         throw new Error('Clear method not implemented.');
     }
+
+    private encodePointer(key: string): MemorySlotPointer {
+        const writer = new BytesWriter(key.length + 2);
+        writer.writeU16(this.pointer);
+        writer.writeString(key);
+
+        return encodePointer(writer.getBuffer());
+    }
 }

package/runtime/storage/Serializable.ts

@@ -4,26 +4,29 @@ import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { BytesReader } from '../buffer/BytesReader';
 import { Revert } from '../types/Revert';
+import { encodePointer } from '../math/abi';
 
 export abstract class Serializable {
     protected pointer: u16;
-    protected subPointer:MemorySlotPointer;
+    protected subPointer: MemorySlotPointer;
 
-    protected constructor(pointer: u16,
-                          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 {
+    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);
+        for (let index: i32 = 0; index < this.chunkCount; index++) {
+            const pointer = this.getPointer(u256.add(this.subPointer, u256.fromU32(index)));
+            const chunk: u256 = Blockchain.getStorageAt(pointer, u256.Zero);
             chunks.push(chunk);
         }
 
@@ -41,8 +44,7 @@ export abstract class Serializable {
 
         for (let index: i32 = 0; index < chunks.length; index++) {
             Blockchain.setStorageAt(
-                this.pointer,
-                u256.add(this.subPointer, u256.fromU32(index)),
+                this.getPointer(u256.add(this.subPointer, u256.fromU32(index))),
                 chunks[index],
             );
         }
@@ -60,7 +62,7 @@ export abstract class Serializable {
     }
 
     protected chunksToBytes(chunks: u256[]): BytesReader {
-        if(this.chunkCount >= 67108863) {
+        if (this.chunkCount >= 67108863) {
             throw new Revert('Too many chunks received');
         }
 
@@ -76,4 +78,12 @@ export abstract class Serializable {
 
         return new BytesReader(buffer);
     }
+
+    private getPointer(subPointer: u256): u256 {
+        const writer = new BytesWriter(34);
+        writer.writeU16(this.pointer);
+        writer.writeU256(subPointer);
+
+        return encodePointer(writer.getBuffer());
+    }
 }

package/runtime/storage/StoredBoolean.ts

@@ -3,10 +3,14 @@ import { Blockchain } from '../env';
 
 @final
 export class StoredBoolean {
+    private readonly u256Pointer: u256;
+
     constructor(
         public pointer: u16,
         private defaultValue: bool,
-    ) {}
+    ) {
+        this.u256Pointer = u256.from(this.pointer);
+    }
 
     private _value: u256 = u256.Zero;
 
@@ -21,14 +25,14 @@ export class StoredBoolean {
     public set value(value: bool) {
         this._value = value ? u256.One : u256.Zero;
 
-        Blockchain.setStorageAt(this.pointer, u256.Zero, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
     }
 
     @inline
     public set(value: u256): this {
         this._value = value;
 
-        Blockchain.setStorageAt(this.pointer, u256.Zero, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -40,8 +44,7 @@ export class StoredBoolean {
 
     private ensureValue(): void {
         this._value = Blockchain.getStorageAt(
-            this.pointer,
-            u256.Zero,
+            this.u256Pointer,
             this.defaultValue ? u256.One : u256.Zero,
         );
     }

package/runtime/storage/StoredString.ts

@@ -1,6 +1,8 @@
 import { u256 } from 'as-bignum/assembly';
 import { Blockchain } from '../env';
 import { SafeMath } from '../types/SafeMath';
+import { encodePointer } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
 
 @final
 export class StoredString {
@@ -30,8 +32,12 @@ export class StoredString {
         return a < b ? a : b;
     }
 
-    private max(a: u32, b: u32): u32 {
-        return a > b ? a : b;
+    private getPointer(key: u256): u256 {
+        const buf = new BytesWriter(34);
+        buf.writeU16(this.pointer);
+        buf.writeU256(key);
+
+        return encodePointer(buf.getBuffer());
     }
 
     private save(): void {
@@ -55,7 +61,7 @@ export class StoredString {
         // 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);
+        Blockchain.setStorageAt(this.getPointer(currentPointer), header);
 
         remainingLength -= bytesToWrite;
         offset += bytesToWrite;
@@ -71,7 +77,7 @@ export class StoredString {
                 0,
             );
             currentPointer = u256.add(currentPointer, u256.One);
-            Blockchain.setStorageAt(this.pointer, currentPointer, storageValue);
+            Blockchain.setStorageAt(this.getPointer(currentPointer), storageValue);
 
             remainingLength -= bytesToWrite;
             offset += bytesToWrite;
@@ -95,7 +101,7 @@ export class StoredString {
     }
 
     private load(): void {
-        const header: u256 = Blockchain.getStorageAt(this.pointer, u256.Zero, u256.Zero);
+        const header: u256 = Blockchain.getStorageAt(this.getPointer(u256.Zero), u256.Zero);
         if (u256.eq(header, u256.Zero)) {
             if (this.defaultValue) {
                 this.value = this.defaultValue;
@@ -120,7 +126,7 @@ export class StoredString {
         while (remainingLength > 0) {
             // Move to the next storage slot
             currentPointer = u256.add(currentPointer, u256.One);
-            currentStorage = Blockchain.getStorageAt(this.pointer, currentPointer, u256.Zero);
+            currentStorage = Blockchain.getStorageAt(this.getPointer(currentPointer), u256.Zero);
 
             // Extract the relevant portion of the string from the current storage slot
             const bytesToRead: u32 = this.min(remainingLength, 32);

package/runtime/storage/StoredU256.ts

@@ -2,14 +2,24 @@ import { u256 } from 'as-bignum/assembly';
 import { SafeMath } from '../types/SafeMath';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { Blockchain } from '../env';
+import { encodePointer } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
 
 @final
 export class StoredU256 {
+    private readonly u256Pointer: u256;
+
     constructor(
         public pointer: u16,
         public subPointer: MemorySlotPointer,
         private defaultValue: u256,
-    ) {}
+    ) {
+        const writer = new BytesWriter(34);
+        writer.writeU16(pointer);
+        writer.writeU256(subPointer);
+
+        this.u256Pointer = encodePointer(writer.getBuffer());
+    }
 
     private _value: u256 = u256.Zero;
 
@@ -28,7 +38,7 @@ export class StoredU256 {
 
         this._value = value;
 
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
     }
 
     @inline
@@ -42,7 +52,28 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
+
+        return this;
+    }
+
+    @inline
+    public addNoCommit(value: u256): this {
+        this._value = SafeMath.add(this._value, value);
+
+        return this;
+    }
+
+    @inline
+    public subNoCommit(value: u256): this {
+        this._value = SafeMath.sub(this._value, value);
+
+        return this;
+    }
+
+    @inline
+    public commit(): this {
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -53,7 +84,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -64,7 +95,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.mul(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -123,7 +154,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.shr(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -134,7 +165,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.and(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -145,7 +176,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.or(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -156,7 +187,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.xor(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -167,7 +198,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.pow(this._value, exponent);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -178,7 +209,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.mod(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -189,7 +220,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, u256.One);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -200,7 +231,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, u256.One);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -209,7 +240,7 @@ export class StoredU256 {
     public set(value: u256): this {
         this._value = value;
 
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -220,6 +251,6 @@ export class StoredU256 {
     }
 
     private ensureValue(): void {
-        this._value = Blockchain.getStorageAt(this.pointer, this.subPointer, this.defaultValue);
+        this._value = Blockchain.getStorageAt(this.u256Pointer, this.defaultValue);
     }
 }