@btc-vision/btc-runtime 1.0.30 → 1.0.31

package/runtime/generic/Map.ts

@@ -1,65 +1,65 @@
-import { Revert } from '../types/Revert';
-
-export class Map<K, V> {
-    protected _keys: K[] = [];
-    protected _values: V[] = [];
-
-    public get size(): i32 {
-        return this._keys.length;
-    }
-
-    public keys(): K[] {
-        return this._keys;
-    }
-
-    public values(): V[] {
-        return this._values;
-    }
-
-    public set(key: K, value: V): void {
-        const index: i32 = this.indexOf(key);
-        if (index == -1) {
-            this._keys.push(key);
-            this._values.push(value);
-        } else {
-            this._values[index] = value;
-        }
-    }
-
-    public indexOf(key: K): i32 {
-        return this._keys.indexOf(key);
-    }
-
-    public get(key: K): V {
-        const index: i32 = this.indexOf(key);
-        if (index == -1) {
-            throw new Revert('Key not found in map');
-        }
-        return this._values[index];
-    }
-
-    public has(key: K): bool {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            if (this._keys[i] == key) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public delete(key: K): 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 = [];
-    }
-}
+import { Revert } from '../types/Revert';
+
+export class Map<K, V> {
+    protected _keys: K[] = [];
+    protected _values: V[] = [];
+
+    public get size(): i32 {
+        return this._keys.length;
+    }
+
+    public keys(): K[] {
+        return this._keys;
+    }
+
+    public values(): V[] {
+        return this._values;
+    }
+
+    public set(key: K, value: V): void {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            this._keys.push(key);
+            this._values.push(value);
+        } else {
+            this._values[index] = value;
+        }
+    }
+
+    public indexOf(key: K): i32 {
+        return this._keys.indexOf(key);
+    }
+
+    public get(key: K): V {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            throw new Revert('Key not found in map');
+        }
+        return this._values[index];
+    }
+
+    public has(key: K): bool {
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            if (this._keys[i] == key) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public delete(key: K): 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 = [];
+    }
+}

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

@@ -51,3 +51,4 @@ 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,46 +1,46 @@
-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++) {
-        let 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++) {
-        let 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;
-
-    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++) {
+        let 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++) {
+        let 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;
+
+    return (2097152 * (h2 & 0xffffffffffffffff) + (h1 >> 11)) & 0xffffffffffffffff;
+}

package/runtime/math/rnd.ts

@@ -1,51 +1,51 @@
-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
-    h *= 0xff51afd7ed558ccd;
-    h ^= h >> 33;
-    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
-    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;
-    let 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
+    h *= 0xff51afd7ed558ccd;
+    h ^= h >> 33;
+    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
+    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;
+    let 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);
+    }
+}