@btc-vision/btc-runtime 1.1.7 → 1.1.8

package/runtime/generic/MapU256.ts

@@ -1,57 +1,57 @@
-import { Revert } from '../types/Revert';
-import { u256 } from '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) {
-            this._keys.push(key);
-            this._values.push(value);
-        } else {
-            this._values[index] = value;
-        }
-    }
-
-    public indexOf(pointerHash: u256): i32 {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            const key = this._keys[i];
-
-            if (u256.eq(key, pointerHash)) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    public has(key: u256): bool {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            if (u256.eq(this._keys[i], key)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public get(key: u256): u256 {
-        const index: i32 = this.indexOf(key);
-        if (index == -1) {
-            throw new Revert('Key not found in map');
-        }
-        return this._values[index];
-    }
-
-    public delete(key: u256): bool {
-        const index: i32 = this.indexOf(key);
-        if (index == -1) {
-            return false;
-        }
-
-        this._keys.splice(index, 1);
-        this._values.splice(index, 1);
-
-        return true;
-    }
-}
+import { Revert } from '../types/Revert';
+import { u256 } from '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) {
+            this._keys.push(key);
+            this._values.push(value);
+        } else {
+            this._values[index] = value;
+        }
+    }
+
+    public indexOf(pointerHash: u256): i32 {
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            const key = this._keys[i];
+
+            if (u256.eq(key, pointerHash)) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public has(key: u256): bool {
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            if (u256.eq(this._keys[i], key)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public get(key: u256): u256 {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            throw new Revert('Key not found in map');
+        }
+        return this._values[index];
+    }
+
+    public delete(key: u256): bool {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            return false;
+        }
+
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+
+        return true;
+    }
+}

package/runtime/index.ts

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

package/runtime/interfaces/DeployContractResponse.ts

@@ -1,12 +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;
-    }
-}
+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/interfaces/IBTC.ts

@@ -1,6 +1,6 @@
-import { Address } from '../types/Address';
-
-export interface IBTC {
-    readonly owner: Address;
-    readonly address: Address;
-}
+import { Address } from '../types/Address';
+
+export interface IBTC {
+    readonly owner: Address;
+    readonly address: Address;
+}

package/runtime/lang/Definitions.ts

@@ -1 +1 @@
-export type Potential<T> = T | null;
+export type Potential<T> = T | null;

package/runtime/math/abi.ts

@@ -1,37 +1,37 @@
-// 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;
-
-export function encodeSelector(name: string): Selector {
-    const typed = Uint8Array.wrap(String.UTF8.encode(name));
-    const hash = Sha256.hash(typed);
-
-    return bytes4(hash);
-}
-
-export function encodePointer(str: string): MemorySlotPointer {
-    const typed = Uint8Array.wrap(String.UTF8.encode(str));
-    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));
-}
+// 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;
+
+export function encodeSelector(name: string): Selector {
+    const typed = Uint8Array.wrap(String.UTF8.encode(name));
+    const hash = Sha256.hash(typed);
+
+    return bytes4(hash);
+}
+
+export function encodePointer(str: string): MemorySlotPointer {
+    const typed = Uint8Array.wrap(String.UTF8.encode(str));
+    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/bytes.ts

@@ -1,34 +1,34 @@
-import { u256 } from 'as-bignum/assembly';
-
-export function bytes(number: u256[]): Uint8Array {
-    const result = new Uint8Array(32 * number.length);
-    for (let i: u8 = 0; i < 32; i++) {
-        const num: Uint8Array = number[31 - i].toUint8Array();
-        for (let j: u8 = 0; j < u8(number.length); j++) {
-            result[i + j * 32] = num[i];
-        }
-    }
-
-    return result;
-}
-
-export function bytes4(number: Uint8Array): u32 {
-    return (u32(number[0]) << 24) | (u32(number[1]) << 16) | (u32(number[2]) << 8) | u32(number[3]);
-}
-
-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])
-    );
-}
-
-export function bytes32(number: Uint8Array): u256 {
-    return u256.fromBytes(number);
-}
+import { u256 } from 'as-bignum/assembly';
+
+export function bytes(number: u256[]): Uint8Array {
+    const result = new Uint8Array(32 * number.length);
+    for (let i: u8 = 0; i < 32; i++) {
+        const num: Uint8Array = number[31 - i].toUint8Array();
+        for (let j: u8 = 0; j < u8(number.length); j++) {
+            result[i + j * 32] = num[i];
+        }
+    }
+
+    return result;
+}
+
+export function bytes4(number: Uint8Array): u32 {
+    return (u32(number[0]) << 24) | (u32(number[1]) << 16) | (u32(number[2]) << 8) | u32(number[3]);
+}
+
+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])
+    );
+}
+
+export function bytes32(number: Uint8Array): u256 {
+    return u256.fromBytes(number);
+}

package/runtime/math/cyrb53.ts

@@ -1,48 +1,48 @@
-export function cyrb53(str: string, seed: i32 = 0): i64 {
-    let h1: i32 = 0xdeadbeef ^ seed;
-    let h2: i32 = 0x41c6ce57 ^ seed;
-    for (let i: i32 = 0; i < str.length; i++) {
-        const ch: i32 = str.charCodeAt(i);
-        h1 = (h1 ^ ch) * 2654435761;
-        h2 = (h2 ^ ch) * 1597334677;
-    }
-
-    h1 = ((h1 ^ (h1 >>> 16)) * 2246822507) ^ ((h2 ^ (h2 >>> 13)) * 3266489909);
-    h2 = ((h2 ^ (h2 >>> 16)) * 2246822507) ^ ((h1 ^ (h1 >>> 13)) * 3266489909);
-
-    return 4294967296 * i64((2097151 & h2) >>> 0) + i64(h1 >>> 0);
-}
-
-export function imul64(a: u64, b: u64): u64 {
-    const aLow: u64 = a & 0xffffffff;
-    const aHigh: u64 = a >> 32;
-    const bLow: u64 = b & 0xffffffff;
-    const bHigh: u64 = b >> 32;
-
-    const low: u64 = aLow * bLow;
-    const middle1: u64 = (aHigh * bLow) << 32;
-    const middle2: u64 = (aLow * bHigh) << 32;
-    const high: u64 = (aHigh * bHigh) << 64;
-
-    return low + middle1 + middle2 + high;
-}
-
-export function cyrb53a(str: u8[], seed: i32 = 0): u64 {
-    let h1: u64 = u64(0xdeadbeef ^ seed);
-    let h2: u64 = u64(0x41c6ce57 ^ seed);
-
-    for (let i: i32 = 0; i < str.length; i++) {
-        const ch: u64 = u64(str[i]);
-        h1 = imul64(h1 ^ ch, 0x85ebca77);
-        h2 = imul64(h2 ^ ch, 0xc2b2ae3d);
-    }
-
-    h1 ^= imul64(h1 ^ (h2 >> 15), 0x735a2d97);
-    h2 ^= imul64(h2 ^ (h1 >> 15), 0xcaf649a9);
-    h1 ^= h2 >> 16;
-    h2 ^= h1 >> 16;
-
-    // We are sure that the result is within the range of u64.
-    // eslint-disable-next-line no-loss-of-precision
-    return (2097152 * (h2 & 0xffffffffffffffff) + (h1 >> 11)) & 0xffffffffffffffff;
-}
+export function cyrb53(str: string, seed: i32 = 0): i64 {
+    let h1: i32 = 0xdeadbeef ^ seed;
+    let h2: i32 = 0x41c6ce57 ^ seed;
+    for (let i: i32 = 0; i < str.length; i++) {
+        const ch: i32 = str.charCodeAt(i);
+        h1 = (h1 ^ ch) * 2654435761;
+        h2 = (h2 ^ ch) * 1597334677;
+    }
+
+    h1 = ((h1 ^ (h1 >>> 16)) * 2246822507) ^ ((h2 ^ (h2 >>> 13)) * 3266489909);
+    h2 = ((h2 ^ (h2 >>> 16)) * 2246822507) ^ ((h1 ^ (h1 >>> 13)) * 3266489909);
+
+    return 4294967296 * i64((2097151 & h2) >>> 0) + i64(h1 >>> 0);
+}
+
+export function imul64(a: u64, b: u64): u64 {
+    const aLow: u64 = a & 0xffffffff;
+    const aHigh: u64 = a >> 32;
+    const bLow: u64 = b & 0xffffffff;
+    const bHigh: u64 = b >> 32;
+
+    const low: u64 = aLow * bLow;
+    const middle1: u64 = (aHigh * bLow) << 32;
+    const middle2: u64 = (aLow * bHigh) << 32;
+    const high: u64 = (aHigh * bHigh) << 64;
+
+    return low + middle1 + middle2 + high;
+}
+
+export function cyrb53a(str: u8[], seed: i32 = 0): u64 {
+    let h1: u64 = u64(0xdeadbeef ^ seed);
+    let h2: u64 = u64(0x41c6ce57 ^ seed);
+
+    for (let i: i32 = 0; i < str.length; i++) {
+        const ch: u64 = u64(str[i]);
+        h1 = imul64(h1 ^ ch, 0x85ebca77);
+        h2 = imul64(h2 ^ ch, 0xc2b2ae3d);
+    }
+
+    h1 ^= imul64(h1 ^ (h2 >> 15), 0x735a2d97);
+    h2 ^= imul64(h2 ^ (h1 >> 15), 0xcaf649a9);
+    h1 ^= h2 >> 16;
+    h2 ^= h1 >> 16;
+
+    // We are sure that the result is within the range of u64.
+    // eslint-disable-next-line no-loss-of-precision
+    return (2097152 * (h2 & 0xffffffffffffffff) + (h1 >> 11)) & 0xffffffffffffffff;
+}

package/runtime/math/rnd.ts

@@ -1,55 +1,55 @@
-let random_state0_64: u64;
-let random_state1_64: u64;
-let random_state0_32: u32;
-let random_state1_32: u32;
-let random_seeded = false;
-
-function murmurHash3(h: u64): u64 {
-    // Force all bits of a hash block to avalanche
-    h ^= h >> 33; // see: https://github.com/aappleby/smhasher
-    // eslint-disable-next-line no-loss-of-precision
-    h *= 0xff51afd7ed558ccd;
-    h ^= h >> 33;
-    // eslint-disable-next-line no-loss-of-precision
-    h *= 0xc4ceb9fe1a85ec53;
-    h ^= h >> 33;
-    return h;
-}
-
-function splitMix32(h: u32): u32 {
-    h += 0x6d2b79f5;
-    h = (h ^ (h >> 15)) * (h | 1);
-    h ^= h + (h ^ (h >> 7)) * (h | 61);
-    return h ^ (h >> 14);
-}
-
-function seedRandom(value: i64): void {
-    // Instead zero seed use golden ratio:
-    // phi = (1 + sqrt(5)) / 2
-    // trunc(2^64 / phi) = 0x9e3779b97f4a7c15
-
-    // eslint-disable-next-line no-loss-of-precision
-    if (value == 0) value = 0x9e3779b97f4a7c15;
-    random_state0_64 = murmurHash3(value);
-    random_state1_64 = murmurHash3(~random_state0_64);
-    random_state0_32 = splitMix32(<u32>value);
-    random_state1_32 = splitMix32(random_state0_32);
-    random_seeded = true;
-}
-
-/**
- * Safe deterministic random number generator
- * @param {u64} seed - The seed to use
- */
-export function randomU64(seed: i64): u64 {
-    if (!random_seeded) seedRandom(seed);
-    let s1 = random_state0_64;
-    const s0 = random_state1_64;
-    random_state0_64 = s0;
-    s1 ^= s1 << 23;
-    s1 ^= s1 >> 17;
-    s1 ^= s0;
-    s1 ^= s0 >> 26;
-    random_state1_64 = s1;
-    return s0;
-}
+let random_state0_64: u64;
+let random_state1_64: u64;
+let random_state0_32: u32;
+let random_state1_32: u32;
+let random_seeded = false;
+
+function murmurHash3(h: u64): u64 {
+    // Force all bits of a hash block to avalanche
+    h ^= h >> 33; // see: https://github.com/aappleby/smhasher
+    // eslint-disable-next-line no-loss-of-precision
+    h *= 0xff51afd7ed558ccd;
+    h ^= h >> 33;
+    // eslint-disable-next-line no-loss-of-precision
+    h *= 0xc4ceb9fe1a85ec53;
+    h ^= h >> 33;
+    return h;
+}
+
+function splitMix32(h: u32): u32 {
+    h += 0x6d2b79f5;
+    h = (h ^ (h >> 15)) * (h | 1);
+    h ^= h + (h ^ (h >> 7)) * (h | 61);
+    return h ^ (h >> 14);
+}
+
+function seedRandom(value: i64): void {
+    // Instead zero seed use golden ratio:
+    // phi = (1 + sqrt(5)) / 2
+    // trunc(2^64 / phi) = 0x9e3779b97f4a7c15
+
+    // eslint-disable-next-line no-loss-of-precision
+    if (value == 0) value = 0x9e3779b97f4a7c15;
+    random_state0_64 = murmurHash3(value);
+    random_state1_64 = murmurHash3(~random_state0_64);
+    random_state0_32 = splitMix32(<u32>value);
+    random_state1_32 = splitMix32(random_state0_32);
+    random_seeded = true;
+}
+
+/**
+ * Safe deterministic random number generator
+ * @param {u64} seed - The seed to use
+ */
+export function randomU64(seed: i64): u64 {
+    if (!random_seeded) seedRandom(seed);
+    let s1 = random_state0_64;
+    const s0 = random_state1_64;
+    random_state0_64 = s0;
+    s1 ^= s1 << 23;
+    s1 ^= s1 >> 17;
+    s1 ^= s0;
+    s1 ^= s0 >> 26;
+    random_state1_64 = s1;
+    return s0;
+}

package/runtime/math/sha256.ts

@@ -1,12 +1,12 @@
-import { sha256 } from '../env/global';
-
-export class Sha256 {
-    static hash(buffer: Uint8Array): Uint8Array {
-        return sha256(buffer);
-    }
-
-    static hash256(buffer: Uint8Array): Uint8Array {
-        const hash = sha256(buffer);
-        return sha256(hash);
-    }
-}
+import { sha256 } from '../env/global';
+
+export class Sha256 {
+    static hash(buffer: Uint8Array): Uint8Array {
+        return sha256(buffer);
+    }
+
+    static hash256(buffer: Uint8Array): Uint8Array {
+        const hash = sha256(buffer);
+        return sha256(hash);
+    }
+}