@btc-vision/btc-runtime 1.4.6 → 1.5.0

package/runtime/generic/Map.ts

@@ -1,6 +1,24 @@
 import { Revert } from '../types/Revert';
 
-export class Map<K, V> {
+export interface IMap<K, V> {
+    readonly size: i32;
+
+    has(key: K): bool;
+
+    set(key: K, value: V): this;
+
+    get(key: K): V;
+
+    delete(key: K): bool;
+
+    clear(): void;
+
+    keys(): K[]; // preliminary
+    values(): V[]; // preliminary
+    toString(): string;
+}
+
+export class Map<K, V> implements IMap<K, V> {
     protected _keys: K[] = [];
     protected _values: V[] = [];
 
@@ -16,7 +34,7 @@ export class Map<K, V> {
         return this._values;
     }
 
-    public set(key: K, value: V): void {
+    public set(key: K, value: V): this {
         const index: i32 = this.indexOf(key);
         if (index == -1) {
             this._keys.push(key);
@@ -24,6 +42,8 @@ export class Map<K, V> {
         } else {
             this._values[index] = value;
         }
+
+        return this;
     }
 
     public indexOf(key: K): i32 {
@@ -63,4 +83,14 @@ export class Map<K, V> {
         this._keys = [];
         this._values = [];
     }
+
+    public toString(): string {
+        const str: string = ``;
+
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            str.concat(`[${this._keys[i]}] => [${this._values[i]}]`);
+        }
+
+        return str;
+    }
 }

package/runtime/generic/MapU256.ts

@@ -3,14 +3,16 @@ import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Map } from './Map';
 
 export class MapU256 extends Map<u256, u256> {
-    public set(key: u256, value: u256): void {
-        const index: i32 = this._keys.indexOf(key);
-        if (index == -1) {
+    public set(key: u256, value: u256): this {
+        const index: i32 = this.indexOf(key);
+        if (index === -1) {
             this._keys.push(key);
             this._values.push(value);
         } else {
             this._values[index] = value;
         }
+
+        return this;
     }
 
     public indexOf(pointerHash: u256): i32 {
@@ -37,7 +39,7 @@ export class MapU256 extends Map<u256, u256> {
 
     public get(key: u256): u256 {
         const index: i32 = this.indexOf(key);
-        if (index == -1) {
+        if (index === -1) {
             throw new Revert('Key not found in map (u256)');
         }
         return this._values[index];
@@ -45,7 +47,7 @@ export class MapU256 extends Map<u256, u256> {
 
     public delete(key: u256): bool {
         const index: i32 = this.indexOf(key);
-        if (index == -1) {
+        if (index === -1) {
             return false;
         }
 

package/runtime/generic/MapUint8Array.ts

@@ -0,0 +1,93 @@
+import { Revert } from '../types/Revert';
+import { IMap } from './Map';
+
+export function eqUint(data: Uint8Array, data2: Uint8Array): bool {
+    if (data.length !== data2.length) return false;
+
+    for (let i = 0; i < data.length; i++) {
+        if (data[i] !== data2[i]) return false;
+    }
+
+    return true;
+}
+
+@final
+export class MapUint8Array implements IMap<Uint8Array, Uint8Array> {
+    protected _keys: Uint8Array[] = [];
+    protected _values: Uint8Array[] = [];
+
+    public get size(): i32 {
+        return this._keys.length;
+    }
+
+    public keys(): Uint8Array[] {
+        return this._keys;
+    }
+
+    public values(): Uint8Array[] {
+        return this._values;
+    }
+
+    public set(key: Uint8Array, value: Uint8Array): this {
+        const index: i32 = this.indexOf(key);
+        if (index === -1) {
+            this._keys.push(key);
+            this._values.push(value);
+        } else {
+            this._values[index] = value;
+        }
+
+        return this;
+    }
+
+    public indexOf(pointerHash: Uint8Array): i32 {
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            const key = this._keys[i];
+
+            if (eqUint(key, pointerHash)) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public has(key: Uint8Array): bool {
+        return this.indexOf(key) !== -1;
+    }
+
+    public get(key: Uint8Array): Uint8Array {
+        const index: i32 = this.indexOf(key);
+        if (index === -1) {
+            throw new Revert('Key not found in map (uint8array)');
+        }
+        return this._values[index];
+    }
+
+    public delete(key: Uint8Array): bool {
+        const index: i32 = this.indexOf(key);
+        if (index === -1) {
+            return false;
+        }
+
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+
+        return true;
+    }
+
+    public clear(): void {
+        this._keys = [];
+        this._values = [];
+    }
+
+    public toString(): string {
+        const str: string = ``;
+
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            str.concat(`[${this._keys[i].toString()}] => [${this._values[i].toString()}]`);
+        }
+
+        return str;
+    }
+}

package/runtime/index.ts

@@ -14,7 +14,6 @@ export * from './buffer/BytesWriter';
 
 /** Interfaces */
 export * from './interfaces/IBTC';
-export * from './interfaces/DeployContractResponse';
 
 /** Events */
 export * from './events/NetEvent';
@@ -43,16 +42,12 @@ export * from './types/SafeMathI128';
 /** Math */
 export * from './math/abi';
 export * from './math/bytes';
-export * from './math/cyrb53';
-export * from './math/sha256';
 export * from './secp256k1/ECPoint';
 
 /** Memory */
 export * from './memory/AddressMemoryMap';
 export * from './memory/StringMemoryMap';
 export * from './memory/MultiStringMemoryMap';
-export * from './memory/MemorySlot';
-export * from './memory/MemorySlotPointer';
 export * from './memory/KeyMerger';
 export * from './memory/MultiAddressMemoryMap';
 export * from './memory/Uint8ArrayMerger';
@@ -67,19 +62,16 @@ export * from './storage/Serializable';
 
 /** Arrays */
 export * from './storage/arrays/StoredAddressArray';
+export * from './storage/arrays/StoredBooleanArray';
+
 export * from './storage/arrays/StoredU8Array';
 export * from './storage/arrays/StoredU16Array';
 export * from './storage/arrays/StoredU32Array';
-export * from './storage/arrays/StoredBooleanArray';
+export * from './storage/arrays/StoredU64Array';
 export * from './storage/arrays/StoredU128Array';
 export * from './storage/arrays/StoredU256Array';
 
-/** Storage Utils */
-export * from './storage/utils/StorageBacked';
-export * from './storage/utils/StorageSlot';
-export * from './storage/utils/StorageStruct';
-export * from './storage/utils/StorageLayout';
-export * from './storage/utils/StorageValue';
+export * from './memory/FastUint8Array';
 
 /** Shared libraries */
 export * from './shared-libraries/TransferHelper';

package/runtime/math/abi.ts

@@ -1,28 +1,88 @@
-// 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 { Sha256 } from './sha256';
+import { bytesToU32 } from './bytes';
+import { sha256 } from '../env/global';
+import { u256 } from '@btc-vision/as-bignum/assembly';
 
 export type Selector = u32;
 
 export function encodeSelector(name: string): Selector {
     const typed = Uint8Array.wrap(String.UTF8.encode(name));
-    const hash = Sha256.hash(typed);
+    const hash = sha256(typed);
 
-    return bytes4(hash);
+    return bytesToU32(hash);
 }
 
-export function encodePointer(uniqueIdentifier: u16, typed: Uint8Array): MemorySlotPointer {
-    const hash: Uint8Array = typed.length !== 32 ? Sha256.hash(typed) : typed;
+/**
+ * Use more gas.
+ * @param uniqueIdentifier
+ * @param typed
+ */
+export function encodePointerUnknownLength(uniqueIdentifier: u16, typed: Uint8Array): Uint8Array {
+    const hash = sha256(typed);
+
+    return encodePointer(uniqueIdentifier, hash, false);
+}
+
+export function ensureAtLeast30Bytes(typed: Uint8Array): Uint8Array {
+    if (typed.length >= 30) {
+        return typed;
+    }
+
+    const result = new Uint8Array(30);
+    for (let i = 0; i < typed.length; i++) {
+        result[i] = typed[i];
+    }
+
+    return result;
+}
+
+@inline
+function toArrayBufferBE(buffer: usize, val: u256): void {
+    // Write the upper 3 chunks (each 64 bits) in one shot:
+    store<u64>(buffer, bswap(val.hi2), 0); // 0..7
+    store<u64>(buffer, bswap(val.hi1), 8); // 8..15
+    store<u64>(buffer, bswap(val.lo2), 16); // 16..23
+
+    // Now handle the final 64 bits (val.lo1) in [32 + 16 + 16] form.
+    //  - lo1High32 = top 32 bits   [bits 63..32]
+    //  - lo1Mid16  = middle 16 bits [bits 31..16]
+    //  - lo1Low16  = bottom 16 bits [bits 15..0]
+    const lo1High32 = u32(val.lo1 >>> 32);
+    const lo1Mid16 = u16((val.lo1 >>> 16) & 0xffff);
+
+    // Store them in ascending offsets. Because each store is little-endian,
+    // we bswap the values so that the final bytes in memory are big-endian.
+
+    // Offsets 24..27 (4 bytes): top 32 bits of lo1
+    store<u32>(buffer, bswap(lo1High32), 24);
+
+    // Offsets 28..29 (2 bytes): mid 16 bits of lo1
+    store<u16>(buffer, bswap(lo1Mid16), 28);
+}
+
+export function u256To30Bytes(value: u256): Uint8Array {
+    const result = new Uint8Array(30);
+    toArrayBufferBE(changetype<usize>(result.dataStart), value);
+    return result;
+}
+
+/**
+ * Optimized pointer encoding, see encodePointerUnknownLength for a more generic version.
+ * @param uniqueIdentifier
+ * @param typed
+ * @param safe
+ */
+export function encodePointer(uniqueIdentifier: u16, typed: Uint8Array, safe: boolean = true): Uint8Array {
+    const array = ensureAtLeast30Bytes(typed);
+
+    if (safe) assert(array.length === 30, `Pointers must be 30 bytes. Got ${array.length}.`);
 
     const finalPointer = new Uint8Array(32);
     finalPointer[0] = uniqueIdentifier & 0xff;
     finalPointer[1] = (uniqueIdentifier >> 8) & 0xff;
 
     for (let i = 0; i < 30; i++) {
-        // drop the last two bytes
-        finalPointer[i + 2] = hash[i];
+        finalPointer[i + 2] = array[i];
     }
 
-    return bytes32(finalPointer);
+    return finalPointer;
 }

package/runtime/math/bytes.ts

@@ -1,57 +1,193 @@
-import { u128, u256 } from '@btc-vision/as-bignum/assembly';
-
-export function bytes(numbers: u256[]): Uint8Array {
-    const len = numbers.length;
-    const result = new Uint8Array(32 * len);
-
-    // Loop through the array in reverse order, so that the last element (index = len-1)
-    // becomes the first chunk in the output, and so on.
-    for (let i = 0; i < len; i++) {
-        // Reverse index to pick elements from the end
-        const rev = len - 1 - i;
-        const chunk: Uint8Array = numbers[rev].toUint8Array();
-
-        // Copy this 32-byte chunk into the output at offset i * 32.
-        const offset = i * 32;
-        for (let b: u32 = 0; b < 32; b++) {
-            result[offset + b] = chunk[b];
-        }
+import { Revert } from '../types/Revert';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { BytesReader } from '../buffer/BytesReader';
+
+/**
+ * Convert a 4-byte big-endian array into a u32.
+ * Index 0 is most significant, index 3 is least significant.
+ */
+@inline
+export function bytesToU32(number: Uint8Array): u32 {
+    if (number.length < 4) {
+        throw new Error('bytesToU32: input must be at least 4 bytes');
+    }
+    return (u32(number[0]) << 24) |
+        (u32(number[1]) << 16) |
+        (u32(number[2]) << 8) |
+        u32(number[3]);
+}
+
+// 32-byte buffer of all zeros
+export const EMPTY_BUFFER: Uint8Array = new Uint8Array(32);
+
+// 30-byte buffer of all zeros
+export const EMPTY_POINTER: Uint8Array = new Uint8Array(30);
+
+// 32-byte buffer representing 1 in big-endian form:
+// index 31 is the least significant byte.
+export const ONE_BUFFER: Uint8Array = new Uint8Array(32);
+ONE_BUFFER[31] = 1;
+
+/**
+ * Return a new 32-byte zero buffer.
+ */
+@inline
+export function GET_EMPTY_BUFFER(): Uint8Array {
+    return new Uint8Array(32);
+}
+
+/**
+ * A helper to add two 32-byte big-endian Uint8Arrays.
+ * Returns a new 32-byte Uint8Array with (a + b) mod 2^256.
+ *
+ * In big-endian, the LSB is at index 31, so we iterate from i = 31 down to 0.
+ */
+@inline
+export function addUint8ArraysBE(a: Uint8Array, b: Uint8Array): Uint8Array {
+    if (a.length !== 32 || b.length !== 32) {
+        throw new Error('addUint8ArraysBE expects 32-byte inputs');
+    }
+
+    const result = new Uint8Array(32);
+    let carry = 0;
+
+    // index 31 is least significant byte
+    for (let i = 31; i >= 0; i--) {
+        const sum = (a[i] as u32) + (b[i] as u32) + carry;
+        result[i] = sum & 0xff;
+        carry = sum >> 8;
     }
 
     return result;
 }
 
-export function bytes4(number: Uint8Array): u32 {
-    return (u32(number[0]) << 24) | (u32(number[1]) << 16) | (u32(number[2]) << 8) | u32(number[3]);
+/**
+ * Convert a u64 value to a 32-byte big-endian Uint8Array,
+ * placing the u64 in the *last* 8 bytes (indices 24..31).
+ * The most significant 24 bytes (indices 0..23) remain 0.
+ */
+@inline
+export function u64ToBE32Bytes(value: u64): Uint8Array {
+    const arr = new Uint8Array(32);
+
+    // Write big-endian into the final 8 bytes:
+    for (let i = 0; i < 8; i++) {
+        arr[31 - i] = <u8>(value & 0xff);
+        value >>= 8;
+    }
+
+    return arr;
 }
 
-export function bytes8(number: Uint8Array): u64 {
-    return (
-        (u64(number[0]) << u64(56)) |
-        (u64(number[1]) << u64(48)) |
-        (u64(number[2]) << u64(40)) |
-        (u64(number[3]) << u64(32)) |
-        (u64(number[4]) << 24) |
-        (u64(number[5]) << 16) |
-        (u64(number[6]) << 8) |
-        u64(number[7])
-    );
+/**
+ * Get the bit at `bitIndex` (0..255) in a 32-byte buffer **in big-endian bit numbering**.
+ * - bitIndex = 0 => the MSB of buffer[0].
+ * - bitIndex = 7 => the LSB of buffer[0].
+ * - bitIndex = 255 => the LSB of buffer[31].
+ */
+@inline
+export function getBit(buffer: Uint8Array, bitIndex: u16): bool {
+    if (bitIndex >= 256) {
+        throw new Revert('Bit index out of range');
+    }
+
+    // Which byte?
+    const byteIndex: u8 = <u8>(bitIndex >>> 3);
+
+    // Which bit within that byte? (MSB = bit offset 7)
+    const offset: u8 = <u8>(7 - (bitIndex & 7));
+
+    const b: u8 = buffer[byteIndex];
+    return ((b >>> offset) & 1) == 1;
 }
 
-export function bytes16(buffer: Uint8Array): u128 {
-    // Validate that the buffer is at least 16 bytes:
-    if (buffer.length < 16) {
-        throw new Error('bytes16: Buffer must be at least 16 bytes long');
+/**
+ * Set or clear the bit at `bitIndex` (0..255) in a 32-byte buffer (**big-endian** bit numbering).
+ * - bitIndex = 0 => sets the MSB of buffer[0].
+ * - bitIndex = 255 => sets the LSB of buffer[31].
+ */
+@inline
+export function setBit(buffer: Uint8Array, bitIndex: u16, bitValue: bool): void {
+    if (bitIndex >= 256) {
+        throw new Revert('Bit index out of range');
+    }
+
+    // Which byte?
+    const byteIndex: u8 = <u8>(bitIndex >>> 3);
+
+    // Which bit within that byte? (MSB = bit offset 7)
+    const offset: u8 = <u8>(7 - (bitIndex & 7));
+
+    let b: u8 = buffer[byteIndex];
+    if (bitValue) {
+        b |= 1 << offset;
+    } else {
+        b &= ~(1 << offset);
     }
 
-    // If it's larger than 16, slice it down:
-    if (buffer.length > 16) {
-        buffer = buffer.slice(0, 16);
+    buffer[byteIndex] = b;
+}
+
+
+/**
+ * Assume the data is at least 16 bytes, read two u64s from it in big-endian order.
+ */
+@inline
+export function readLengthAndStartIndex(data: Uint8Array): u64[] {
+    if (data.length < 16) {
+        return [0, 0];
     }
 
-    return u128.fromBytes(buffer);
+    const reader = new BytesReader(data);
+    const length = reader.readU64();
+    const startIndex = reader.readU64();
+
+    return [length, startIndex];
 }
 
-export function bytes32(number: Uint8Array): u256 {
-    return u256.fromBytes(number);
+/**
+ * Write two u64s into a 32-byte buffer in big-endian order
+ */
+@inline
+export function writeLengthAndStartIndex(length: u64, startIndex: u64): Uint8Array {
+    const writer = new BytesWriter(32);
+    writer.writeU64(length);
+    writer.writeU64(startIndex);
+
+    return writer.getBuffer();
 }
+
+/**
+ * Encode a 2-byte pointer + subPointer into a 32-byte buffer in big-endian order.
+ */
+@inline
+export function encodeBasePointer(pointer: u16, subPointer: Uint8Array): Uint8Array {
+    const writer = new BytesWriter(32);
+    writer.writeU16(pointer);
+    writer.writeBytes(subPointer);
+
+    return writer.getBuffer();
+}
+
+@inline
+export function bigEndianAdd(base: Uint8Array, increment: u64): Uint8Array {
+    const out = new Uint8Array(32);
+
+    // Copy the base pointer
+    for (let i = 0; i < 32; i++) {
+        out[i] = base[i];
+    }
+
+    // If this is truly big-endian, out[0] is the MSB, out[31] is the LSB.
+    // So to add `increment`, we start from out[31] backward.
+    let carry: u64 = increment;
+    for (let i = 31; i >= 0; i--) {
+        const sum = <u64>out[i] + (carry & 0xFF);
+        out[i] = <u8>(sum & 0xFF);
+        carry = sum >> 8;
+        if (carry == 0 || i == 0) {
+            break;
+        }
+    }
+    return out;
+}

package/runtime/memory/AddressMemoryMap.ts

@@ -1,44 +1,50 @@
-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 { BytesWriter } from '../buffer/BytesWriter';
 import { Address } from '../types/Address';
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { EMPTY_BUFFER } from '../math/bytes';
 
 @final
-export class AddressMemoryMap<V extends MemorySlotData<u256>> {
+export class AddressMemoryMap {
     public pointer: u16;
 
     constructor(
         pointer: u16,
-        private readonly defaultValue: V,
     ) {
         this.pointer = pointer;
     }
 
-    public set(key: Address, value: V): this {
-        const keyHash: MemorySlotPointer = this.encodePointer(key);
+    public setAsUint8Array(key: Address, value: Uint8Array): this {
+        const keyHash: Uint8Array = this.encodePointer(key);
         Blockchain.setStorageAt(keyHash, value);
 
         return this;
     }
 
-    public get(key: Address): MemorySlotData<u256> {
-        const keyHash: MemorySlotPointer = this.encodePointer(key);
+    public set(key: Address, value: u256): this {
+        return this.setAsUint8Array(key, value.toUint8Array(true));
+    }
 
-        return Blockchain.getStorageAt(keyHash, this.defaultValue);
+    public getAsUint8Array(key: Address): Uint8Array {
+        const keyHash: Uint8Array = this.encodePointer(key);
+
+        return Blockchain.getStorageAt(keyHash);
+    }
+
+    public get(address: Address): u256 {
+        const resp = this.getAsUint8Array(address);
+
+        return u256.fromUint8ArrayBE(resp);
     }
 
     public has(key: Address): bool {
-        const keyHash: MemorySlotPointer = this.encodePointer(key);
+        const keyHash: Uint8Array = this.encodePointer(key);
 
         return Blockchain.hasStorageAt(keyHash);
     }
 
-    @unsafe
     public delete(key: Address): bool {
-        this.set(key, this.defaultValue);
+        this.setAsUint8Array(key, EMPTY_BUFFER);
 
         return true;
     }
@@ -48,10 +54,7 @@ export class AddressMemoryMap<V extends MemorySlotData<u256>> {
         throw new Error('Method not implemented.');
     }
 
-    private encodePointer(key: Address): MemorySlotPointer {
-        const writer = new BytesWriter(key.length);
-        writer.writeBytes(key);
-
-        return encodePointer(this.pointer, writer.getBuffer());
+    private encodePointer(key: Address): Uint8Array {
+        return encodePointer(this.pointer, key.slice(0, 30), true);
     }
 }