@btc-vision/btc-runtime 1.4.7 → 1.5.1

package/runtime/memory/FastUint8Array.ts

@@ -0,0 +1,122 @@
+import { Revert } from '../types/Revert';
+import { ArrayBuffer } from 'arraybuffer';
+
+export class FastUint8Array {
+    public length: i32;
+    private ptr: usize;
+
+    [key: number]: u8;
+
+    constructor(length: i32) {
+        if (length < 0) {
+            throw new Revert('Negative length in FastUint8Array constructor');
+        }
+
+        this.length = length;
+        this.ptr = __alloc(<usize>length);
+    }
+
+    public static fromUint8Array(arr: Uint8Array): FastUint8Array {
+        const buffer = new FastUint8Array(arr.length);
+        for (let i: u32 = 0; i < arr.length; i++) {
+            buffer[i] = arr[i];
+        }
+
+        return buffer;
+    }
+
+    toArrayBuffer(): ArrayBuffer {
+        const arr = new Uint8Array(this.length);
+        for (let i: u32 = 0; i < arr.length; i++) {
+            arr[i] = this[i];
+        }
+
+        return arr.buffer;
+    }
+
+    /**
+     * Fills the buffer with a specified byte value.
+     */
+    fill(value: u8): void {
+        memory.fill(this.ptr, value, <usize>this.length);
+    }
+
+    /**
+     * Copies bytes from another FastUint8Array into this one, starting at `destOffset`.
+     */
+    copyFrom(source: FastUint8Array, destOffset: i32 = 0): void {
+        if (destOffset < 0) {
+            throw new Revert(`Negative destOffset in copyFrom: ${destOffset}`);
+        }
+
+        let maxBytes = source.length;
+        const destRemaining = this.length - destOffset;
+        if (destRemaining < maxBytes) {
+            maxBytes = destRemaining;
+        }
+
+        if (maxBytes <= 0) return;
+
+        memory.copy(
+            this.ptr + <usize>destOffset,
+            source.ptr,
+            <usize>maxBytes,
+        );
+    }
+
+    free(): void {
+        if (this.ptr != 0) {
+            __free(this.ptr);
+            this.ptr = 0;
+            this.length = 0;
+        }
+    }
+
+    /**
+     * Safe read operator: buffer[i]
+     * Throws on out-of-bounds.
+     */
+    @operator('[]')
+    private __get(index: i32): u8 {
+        if (<u32>index >= <u32>this.length) {
+            throw new Revert('Index out of range in __get');
+        }
+        return load<u8>(this.ptr + <usize>index);
+    }
+
+    /**
+     * Safe write operator: buffer[i] = value
+     * Throws on out-of-bounds.
+     */
+    @operator('[]=')
+    private __set(index: i32, value: u8): void {
+        if (<u32>index >= <u32>this.length) {
+            throw new Revert('Index out of range in __set');
+        }
+        store<u8>(this.ptr + <usize>index, value);
+    }
+
+    /**
+     * Braces read operator: buffer{i}
+     * Now also throws on out-of-bounds for safety.
+     */
+    @operator('{}')
+    private __uget(index: i32): u8 {
+        if (<u32>index >= <u32>this.length) {
+            throw new Revert('Index out of range in __uget');
+        }
+        return load<u8>(this.ptr + <usize>index);
+    }
+
+    /**
+     * Braces write operator: buffer{i} = value
+     * Now also throws on out-of-bounds.
+     */
+    @operator('{}=')
+    private __uset(index: i32, value: u8): void {
+        if (<u32>index >= <u32>this.length) {
+            throw new Revert('Index out of range in __uset');
+        }
+        store<u8>(this.ptr + <usize>index, value);
+    }
+}

package/runtime/memory/KeyMerger.ts

@@ -1,44 +1,34 @@
-import { MemorySlotData } from './MemorySlot';
-import { u256 } from '@btc-vision/as-bignum/assembly';
-import { Blockchain } from '../env';
-import { MemorySlotPointer } from './MemorySlotPointer';
-import { encodePointer } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
+import { Blockchain } from '../env';
+import { encodePointerUnknownLength } from '../math/abi';
+
 
 @final
-export class KeyMerger<K extends string, K2 extends string, V extends MemorySlotData<u256>> {
+export class KeyMerger<K extends string, K2 extends string, V extends Uint8Array> {
     public parentKey: K;
-
     public pointer: u16;
 
-    constructor(
-        parent: K,
-        pointer: u16,
-        private readonly defaultValue: V,
-    ) {
+    constructor(parent: K, pointer: u16) {
         this.pointer = pointer;
-
         this.parentKey = parent;
     }
 
     public set(key2: K2, value: V): this {
-        const mergedKey: string = `${this.parentKey}${key2}`;
-        const keyHash: MemorySlotPointer = this.encodePointer(mergedKey);
+        const mergedKey: string = this.mergeKey(key2);
+        const keyHash: Uint8Array = this.encodePointer(mergedKey);
 
         Blockchain.setStorageAt(keyHash, value);
 
         return this;
     }
 
-    public get(key: K): MemorySlotData<u256> {
-        const mergedKey: string = `${this.parentKey}${key}`;
-
-        return Blockchain.getStorageAt(this.encodePointer(mergedKey), this.defaultValue);
+    public get(key: K): Uint8Array {
+        const mergedKey: string = this.mergeKey(key);
+        return Blockchain.getStorageAt(this.encodePointer(mergedKey));
     }
 
     public has(key: K): bool {
-        const mergedKey: string = `${this.parentKey}${key}`;
-
+        const mergedKey: string = this.mergeKey(key);
         return Blockchain.hasStorageAt(this.encodePointer(mergedKey));
     }
 
@@ -52,10 +42,22 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
         throw new Error('Clear method not implemented.');
     }
 
-    private encodePointer(key: string): MemorySlotPointer {
+    /**
+     * Merges the parentKey and the provided key by prefixing each with its length.
+     * This avoids collisions such as:
+     *   parentKey = "abc", key = "def"  => "3:abc3:def"
+     *   parentKey = "ab",  key = "cdef" => "2:ab4:cdef"
+     */
+    @inline
+    private mergeKey(key: string): string {
+        return `${this.parentKey.length}:${this.parentKey}${key.length}:${key}`;
+    }
+
+    @inline
+    private encodePointer(key: string): Uint8Array {
         const writer = new BytesWriter(key.length);
         writer.writeString(key);
 
-        return encodePointer(this.pointer, writer.getBuffer());
+        return encodePointerUnknownLength(this.pointer, writer.getBuffer());
     }
 }

package/runtime/memory/MultiAddressMemoryMap.ts

@@ -1,51 +1,54 @@
-import { MemorySlotData } from './MemorySlot';
-import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Uint8ArrayMerger } from './Uint8ArrayMerger';
 import { Address } from '../types/Address';
 
 @final
-export class MultiAddressMemoryMap<V extends MemorySlotData<u256>> extends Map<
+export class MultiAddressMemoryMap extends Map<
     Address,
-    Uint8ArrayMerger<V>
+    Uint8ArrayMerger
 > {
     public pointer: u16;
 
     constructor(
         pointer: u16,
-        private readonly defaultValue: V,
     ) {
         super();
 
         this.pointer = pointer;
     }
 
-    public get(key: Address): Uint8ArrayMerger<V> {
+    @inline
+    public get(key: Address): Uint8ArrayMerger {
         this.createKeyMerger(key);
 
         return super.get(key);
     }
 
-    public set(key: Address, value: Uint8ArrayMerger<V>): this {
+    @inline
+    public set(key: Address, value: Uint8ArrayMerger): this {
         this.createKeyMerger(key);
 
         return <this>super.set(key, value);
     }
 
+    @inline
     public has(key: Address): bool {
         return super.has(key);
     }
 
+    @inline
     public delete(key: Address): bool {
         return super.delete(key);
     }
 
+    @inline
     public clear(): void {
         super.clear();
     }
 
+    @inline
     private createKeyMerger(key: Address): void {
         if (!super.has(key)) {
-            super.set(key, new Uint8ArrayMerger<V>(key, this.pointer, this.defaultValue));
+            super.set(key, new Uint8ArrayMerger(key, this.pointer));
         }
     }
 }

package/runtime/memory/MultiStringMemoryMap.ts

@@ -1,30 +1,29 @@
-import { MemorySlotData } from './MemorySlot';
-import { u256 } from '@btc-vision/as-bignum/assembly';
 import { KeyMerger } from './KeyMerger';
 
 @final
 export class MultiStringMemoryMap<
     K extends string,
     K2 extends string,
-    V extends MemorySlotData<u256>,
+    V extends Uint8Array,
 > extends Map<K, KeyMerger<K, K2, V>> {
     public pointer: u16;
 
     constructor(
         pointer: u16,
-        private readonly defaultValue: V,
     ) {
         super();
 
         this.pointer = pointer;
     }
 
+    @inline
     public get(key: K): KeyMerger<K, K2, V> {
         this.createKeyMerger(key);
 
         return super.get(key);
     }
 
+    @inline
     public setUpperKey(key: K, key2: K2, value: V): this {
         this.createKeyMerger(key);
 
@@ -36,27 +35,31 @@ export class MultiStringMemoryMap<
         return this;
     }
 
+    @inline
     public set(key: K, value: KeyMerger<K, K2, V>): this {
         this.createKeyMerger(key);
 
         return <this>super.set(key, value);
     }
 
+    @inline
     public has(key: K): bool {
         return super.has(key);
     }
 
+    @inline
     public delete(key: K): bool {
         return super.delete(key);
     }
 
+    @inline
     public clear(): void {
         super.clear();
     }
 
     private createKeyMerger(key: K): void {
         if (!super.has(key)) {
-            super.set(key, new KeyMerger<K, K2, V>(key, this.pointer, this.defaultValue));
+            super.set(key, new KeyMerger<K, K2, V>(key, this.pointer));
         }
     }
 }

package/runtime/memory/StringMemoryMap.ts

@@ -1,43 +1,43 @@
-import { MemorySlotPointer } from './MemorySlotPointer';
 import { Blockchain } from '../env';
-import { encodePointer } from '../math/abi';
-import { MemorySlotData } from './MemorySlot';
-import { u256 } from '@btc-vision/as-bignum/assembly';
+import { encodePointerUnknownLength } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
+import { EMPTY_BUFFER } from '../math/bytes';
 
 @final
-export class StringMemoryMap<K extends string, V extends MemorySlotData<u256>> {
+export class StringMemoryMap<K extends string> {
     public pointer: u16;
 
     constructor(
         pointer: u16,
-        private readonly defaultValue: V,
     ) {
         this.pointer = pointer;
     }
 
-    public set(key: K, value: V): this {
-        const keyHash: MemorySlotPointer = this.encodePointer(key);
+    @inline
+    public set(key: K, value: Uint8Array): this {
+        const keyHash: Uint8Array = this.encodePointer(key);
         Blockchain.setStorageAt(keyHash, value);
 
         return this;
     }
 
-    public get(key: K): MemorySlotData<u256> {
-        const keyHash: MemorySlotPointer = this.encodePointer(key);
+    @inline
+    public get(key: K): Uint8Array {
+        const keyHash: Uint8Array = this.encodePointer(key);
 
-        return Blockchain.getStorageAt(keyHash, this.defaultValue);
+        return Blockchain.getStorageAt(keyHash);
     }
 
+    @inline
     public has(key: K): bool {
-        const keyHash: MemorySlotPointer = this.encodePointer(key);
+        const keyHash: Uint8Array = this.encodePointer(key);
 
         return Blockchain.hasStorageAt(keyHash);
     }
 
     @unsafe
     public delete(key: K): bool {
-        this.set(key, this.defaultValue);
+        this.set(key, EMPTY_BUFFER);
 
         return true;
     }
@@ -47,10 +47,10 @@ export class StringMemoryMap<K extends string, V extends MemorySlotData<u256>> {
         throw new Error('Method not implemented.');
     }
 
-    private encodePointer(key: K): MemorySlotPointer {
+    private encodePointer(key: K): Uint8Array {
         const writer = new BytesWriter(key.length);
         writer.writeString(key);
 
-        return encodePointer(this.pointer, writer.getBuffer());
+        return encodePointerUnknownLength(this.pointer, writer.getBuffer());
     }
 }

package/runtime/memory/Uint8ArrayMerger.ts

@@ -1,12 +1,10 @@
-import { MemorySlotData } from './MemorySlot';
-import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Blockchain } from '../env';
-import { MemorySlotPointer } from './MemorySlotPointer';
-import { encodePointer } from '../math/abi';
+import { encodePointerUnknownLength } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 
 @final
-export class Uint8ArrayMerger<V extends MemorySlotData<u256>> {
+export class Uint8ArrayMerger {
     public parentKey: Uint8Array;
 
     public pointer: u16;
@@ -14,28 +12,37 @@ export class Uint8ArrayMerger<V extends MemorySlotData<u256>> {
     constructor(
         parent: Uint8Array,
         pointer: u16,
-        private readonly defaultValue: V,
     ) {
         this.pointer = pointer;
 
         this.parentKey = parent;
     }
 
-    public set(key: Uint8Array, value: V): this {
-        const keyHash: MemorySlotPointer = this.getKeyHash(key);
+    public setAsUint8Array(key: Uint8Array, value: Uint8Array): this {
+        const keyHash: Uint8Array = this.getKeyHash(key);
         Blockchain.setStorageAt(keyHash, value);
 
         return this;
     }
 
-    public get(key: Uint8Array): MemorySlotData<u256> {
-        const keyHash: MemorySlotPointer = this.getKeyHash(key);
+    public set(key: Uint8Array, value: u256): this {
+        return this.setAsUint8Array(key, value.toUint8Array(true));
+    }
+
+    public getAsUint8Array(key: Uint8Array): Uint8Array {
+        const keyHash: Uint8Array = this.getKeyHash(key);
+
+        return Blockchain.getStorageAt(keyHash);
+    }
+
+    public get(key: Uint8Array): u256 {
+        const data = this.getAsUint8Array(key);
 
-        return Blockchain.getStorageAt(keyHash, this.defaultValue);
+        return u256.fromUint8ArrayBE(data);
     }
 
     public has(key: Uint8Array): bool {
-        const mergedKey: MemorySlotPointer = this.getKeyHash(key);
+        const mergedKey: Uint8Array = this.getKeyHash(key);
 
         return Blockchain.hasStorageAt(mergedKey);
     }
@@ -50,7 +57,7 @@ export class Uint8ArrayMerger<V extends MemorySlotData<u256>> {
         throw new Error('Clear method not implemented.');
     }
 
-    private getKeyHash(key: Uint8Array): MemorySlotPointer {
+    private getKeyHash(key: Uint8Array): Uint8Array {
         const writer: BytesWriter = new BytesWriter(key.byteLength + this.parentKey.byteLength);
 
         writer.writeBytes(this.parentKey);
@@ -59,7 +66,7 @@ export class Uint8ArrayMerger<V extends MemorySlotData<u256>> {
         return this.encodePointer(writer);
     }
 
-    private encodePointer(writer: BytesWriter): MemorySlotPointer {
-        return encodePointer(this.pointer, writer.getBuffer());
+    private encodePointer(writer: BytesWriter): Uint8Array {
+        return encodePointerUnknownLength(this.pointer, writer.getBuffer());
     }
 }

package/runtime/storage/Serializable.ts

@@ -1,18 +1,19 @@
-import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesReader } from '../buffer/BytesReader';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { Revert } from '../types/Revert';
-import { U256_BYTE_LENGTH } from '../utils';
+
+export const SERIALIZED_POINTER_LENGTH: u8 = 29;
 
 // Similar to a struct in Solidity. (Use in worst case scenario, consume a lot of gas)
 export abstract class Serializable {
     protected pointer: u16;
-    protected subPointer: MemorySlotPointer;
+    protected subPointer: Uint8Array;
+
+    protected constructor(pointer: u16, subPointer: Uint8Array) {
+        if (subPointer.length !== SERIALIZED_POINTER_LENGTH) throw new Revert(`Sub pointer length must be ${SERIALIZED_POINTER_LENGTH} bytes.`);
 
-    protected constructor(pointer: u16, subPointer: MemorySlotPointer) {
         this.pointer = pointer;
         this.subPointer = subPointer;
     }
@@ -24,14 +25,14 @@ export abstract class Serializable {
 
     public abstract readFromBuffer(reader: BytesReader): void;
 
-    public abstract exists(chunk: u256, index: u8): boolean;
+    public abstract exists(chunk: Uint8Array, index: u8): boolean;
 
     public load(): boolean {
-        const chunks: u256[] = [];
+        const chunks: Uint8Array[] = [];
 
         for (let index: u8 = 0; index < this.chunkCount; index++) {
             const pointer = this.getPointer(this.subPointer, index);
-            const chunk: u256 = Blockchain.getStorageAt(pointer, u256.Zero);
+            const chunk: Uint8Array = Blockchain.getStorageAt(pointer);
 
             if (!this.exists(chunk, index)) {
                 return false;
@@ -49,7 +50,7 @@ export abstract class Serializable {
     public save(): void {
         const writer: BytesWriter = this.writeToBuffer();
         const buffer = writer.getBuffer();
-        const chunks: u256[] = this.bytesToChunks(buffer);
+        const chunks: Uint8Array[] = this.bytesToChunks(buffer);
 
         if (chunks.length !== this.chunkCount) {
             throw new Revert(
@@ -69,8 +70,8 @@ export abstract class Serializable {
         }
     }
 
-    protected bytesToChunks(buffer: Uint8Array): u256[] {
-        const chunks: u256[] = [];
+    protected bytesToChunks(buffer: Uint8Array): Uint8Array[] {
+        const chunks: Uint8Array[] = [];
 
         for (let index: i32 = 0; index < buffer.byteLength; index += 32) {
             if (chunks.length === 256) {
@@ -78,13 +79,13 @@ export abstract class Serializable {
             }
 
             const chunk = buffer.slice(index, index + 32);
-            chunks.push(u256.fromBytes(chunk, true));
+            chunks.push(chunk);
         }
 
         return chunks;
     }
 
-    protected chunksToBytes(chunks: u256[]): BytesReader {
+    protected chunksToBytes(chunks: Uint8Array[]): BytesReader {
         if (this.chunkCount > u8(255)) {
             throw new Revert(`Too many chunks received. You may only write up to 8160 bytes per object.`);
         }
@@ -93,7 +94,7 @@ export abstract class Serializable {
         let offset: i32 = 0;
 
         for (let indexChunk: i32 = 0; indexChunk < chunks.length; indexChunk++) {
-            const bytes: u8[] = chunks[indexChunk].toBytes(true);
+            const bytes: Uint8Array = chunks[indexChunk];
             for (let indexByte: i32 = 0; indexByte < bytes.length; indexByte++) {
                 buffer[offset++] = bytes[indexByte];
             }
@@ -102,12 +103,10 @@ export abstract class Serializable {
         return new BytesReader(buffer);
     }
 
-    protected getPointer(subPointer: u256, index: u8): u256 {
-        const writer = new BytesWriter(U256_BYTE_LENGTH);
-        writer.writeU256(subPointer);
-
-        // Discard the first byte for offset.
-        writer.writeU8At(index, 0);
+    protected getPointer(subPointer: Uint8Array, index: u8): Uint8Array {
+        const writer = new BytesWriter(30);
+        writer.writeU8(index);
+        writer.writeBytes(subPointer);
 
         return encodePointer(this.pointer, writer.getBuffer());
     }

package/runtime/storage/StoredAddress.ts

@@ -1,31 +1,28 @@
-import { u256 } from '@btc-vision/as-bignum/assembly';
-import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
 import { Address } from '../types/Address';
+import { EMPTY_POINTER } from '../math/bytes';
+import { eqUint } from '../generic/MapUint8Array';
 
+/**
+ * Default is Address.dead();
+ */
 @final
 export class StoredAddress {
-    private readonly addressPointer: u256;
-    private readonly defaultValue: u256;
+    private readonly addressPointer: Uint8Array;
 
-    constructor(public pointer: u16, defaultValue: Address) {
-        const writer = new BytesWriter(32);
-
-        this.defaultValue = u256.fromBytes(defaultValue);
-        this.addressPointer = encodePointer(pointer, writer.getBuffer());
+    constructor(public pointer: u16) {
+        this.addressPointer = encodePointer(pointer, EMPTY_POINTER);
     }
 
-    private _value: Address = new Address();
+    private _value: Address = Address.dead();
 
-    @inline
     public get value(): Address {
         this.ensureValue();
 
         return this._value;
     }
 
-    @inline
     public set value(value: Address) {
         if (value === this.value) {
             return;
@@ -33,11 +30,15 @@ export class StoredAddress {
 
         this._value = value;
 
-        Blockchain.setStorageAt(this.addressPointer, u256.fromBytes(this._value));
+        Blockchain.setStorageAt(this.addressPointer, this._value);
+    }
+
+    public isDead(): bool {
+        return eqUint(Address.dead(), this.value);
     }
 
     private ensureValue(): void {
-        const value = Blockchain.getStorageAt(this.addressPointer, this.defaultValue);
-        this._value.set(value.toBytes());
+        const value = Blockchain.getStorageAt(this.addressPointer);
+        this._value.set(value);
     }
 }