@btc-vision/btc-runtime 1.0.30 → 1.1.0

package/runtime/memory/KeyMerger.ts

@@ -1,53 +1,53 @@
-import { MemorySlotData } from './MemorySlot';
-import { u256 } from 'as-bignum/assembly';
-import { Blockchain } from '../env';
-import { MemorySlotPointer } from './MemorySlotPointer';
-import { encodePointer } from '../math/abi';
-
-@final
-export class KeyMerger<K extends string, K2 extends string, V extends MemorySlotData<u256>> {
-    public parentKey: K;
-
-    public pointer: u16;
-
-    constructor(
-        parent: K,
-        pointer: u16,
-        private readonly defaultValue: V,
-    ) {
-        this.pointer = pointer;
-
-        this.parentKey = parent;
-    }
-
-    public set(key2: K2, value: V): this {
-        const mergedKey: string = `${this.parentKey}${key2}`;
-        const keyHash: MemorySlotPointer = encodePointer(mergedKey);
-
-        Blockchain.setStorageAt(this.pointer, keyHash, value);
-
-        return this;
-    }
-
-    public get(key: K): MemorySlotData<u256> {
-        const mergedKey: string = `${this.parentKey}${key}`;
-
-        return Blockchain.getStorageAt(this.pointer, encodePointer(mergedKey), this.defaultValue);
-    }
-
-    public has(key: K): bool {
-        const mergedKey: string = `${this.parentKey}${key}`;
-
-        return Blockchain.hasStorageAt(this.pointer, encodePointer(mergedKey));
-    }
-
-    @unsafe
-    public delete(_key: K): bool {
-        throw new Error('Method not implemented.');
-    }
-
-    @unsafe
-    public clear(): void {
-        throw new Error('Clear method not implemented.');
-    }
-}
+import { MemorySlotData } from './MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+import { MemorySlotPointer } from './MemorySlotPointer';
+import { encodePointer } from '../math/abi';
+
+@final
+export class KeyMerger<K extends string, K2 extends string, V extends MemorySlotData<u256>> {
+    public parentKey: K;
+
+    public pointer: u16;
+
+    constructor(
+        parent: K,
+        pointer: u16,
+        private readonly defaultValue: V,
+    ) {
+        this.pointer = pointer;
+
+        this.parentKey = parent;
+    }
+
+    public set(key2: K2, value: V): this {
+        const mergedKey: string = `${this.parentKey}${key2}`;
+        const keyHash: MemorySlotPointer = encodePointer(mergedKey);
+
+        Blockchain.setStorageAt(this.pointer, keyHash, value);
+
+        return this;
+    }
+
+    public get(key: K): MemorySlotData<u256> {
+        const mergedKey: string = `${this.parentKey}${key}`;
+
+        return Blockchain.getStorageAt(this.pointer, encodePointer(mergedKey), this.defaultValue);
+    }
+
+    public has(key: K): bool {
+        const mergedKey: string = `${this.parentKey}${key}`;
+
+        return Blockchain.hasStorageAt(this.pointer, encodePointer(mergedKey));
+    }
+
+    @unsafe
+    public delete(_key: K): bool {
+        throw new Error('Method not implemented.');
+    }
+
+    @unsafe
+    public clear(): void {
+        throw new Error('Clear method not implemented.');
+    }
+}

package/runtime/memory/MemorySlot.ts

@@ -1 +1 @@
-export type MemorySlotData<T> = T;
+export type MemorySlotData<T> = T;

package/runtime/memory/MemorySlotPointer.ts

@@ -1,3 +1,3 @@
-import { u256 } from 'as-bignum/assembly';
-
-export type MemorySlotPointer = u256;
+import { u256 } from 'as-bignum/assembly';
+
+export type MemorySlotPointer = u256;

package/runtime/memory/MultiAddressMemoryMap.ts

@@ -1,62 +1,62 @@
-import { MemorySlotData } from './MemorySlot';
-import { u256 } from 'as-bignum/assembly';
-import { KeyMerger } from './KeyMerger';
-
-@final
-export class MultiAddressMemoryMap<
-    K extends string,
-    K2 extends string,
-    V extends MemorySlotData<u256>,
-> extends Map<K, KeyMerger<K, K2, V>> {
-    public pointer: u16;
-
-    constructor(
-        pointer: u16,
-        private readonly defaultValue: V,
-    ) {
-        super();
-
-        this.pointer = pointer;
-    }
-
-    public get(key: K): KeyMerger<K, K2, V> {
-        this.createKeyMerger(key);
-
-        return super.get(key);
-    }
-
-    public setUpperKey(key: K, key2: K2, value: V): this {
-        this.createKeyMerger(key);
-
-        const subMap = super.get(key);
-        if (subMap) {
-            subMap.set(key2, value);
-        }
-
-        return this;
-    }
-
-    public set(key: K, value: KeyMerger<K, K2, V>): this {
-        this.createKeyMerger(key);
-
-        return <this>super.set(key, value);
-    }
-
-    public has(key: K): bool {
-        return super.has(key);
-    }
-
-    public delete(key: K): bool {
-        return super.delete(key);
-    }
-
-    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));
-        }
-    }
-}
+import { MemorySlotData } from './MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+import { KeyMerger } from './KeyMerger';
+
+@final
+export class MultiAddressMemoryMap<
+    K extends string,
+    K2 extends string,
+    V extends MemorySlotData<u256>,
+> extends Map<K, KeyMerger<K, K2, V>> {
+    public pointer: u16;
+
+    constructor(
+        pointer: u16,
+        private readonly defaultValue: V,
+    ) {
+        super();
+
+        this.pointer = pointer;
+    }
+
+    public get(key: K): KeyMerger<K, K2, V> {
+        this.createKeyMerger(key);
+
+        return super.get(key);
+    }
+
+    public setUpperKey(key: K, key2: K2, value: V): this {
+        this.createKeyMerger(key);
+
+        const subMap = super.get(key);
+        if (subMap) {
+            subMap.set(key2, value);
+        }
+
+        return this;
+    }
+
+    public set(key: K, value: KeyMerger<K, K2, V>): this {
+        this.createKeyMerger(key);
+
+        return <this>super.set(key, value);
+    }
+
+    public has(key: K): bool {
+        return super.has(key);
+    }
+
+    public delete(key: K): bool {
+        return super.delete(key);
+    }
+
+    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));
+        }
+    }
+}

package/runtime/shared-libraries/OP20Utils.ts

@@ -0,0 +1,21 @@
+import { Address } from '../types/Address';
+import { u256 } from 'as-bignum/assembly';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { Blockchain } from '../env';
+import { encodeSelector, Selector } from '../math/abi';
+
+export class OP20Utils {
+    public static get BALANCE_OF_SELECTOR(): Selector {
+        return encodeSelector('balanceOf');
+    }
+
+    public static balanceOf(token: Address, owner: Address): u256 {
+        const calldata: BytesWriter = new BytesWriter();
+        calldata.writeSelector(OP20Utils.BALANCE_OF_SELECTOR);
+        calldata.writeAddress(owner);
+
+        const response = Blockchain.call(token, calldata);
+
+        return response.readU256();
+    }
+}

package/runtime/shared-libraries/TransferHelper.ts

@@ -1,64 +1,64 @@
-import { u256 } from 'as-bignum/assembly/integer/u256';
-import { encodeSelector, Selector } from '../math/abi';
-import { Address } from '../types/Address';
-import { BytesWriter } from '../buffer/BytesWriter';
-import { Blockchain } from '../env';
-import { Revert } from '../types/Revert';
-
-export class TransferHelper {
-    public static get APPROVE_SELECTOR(): Selector {
-        return encodeSelector('approve');
-    }
-
-    public static get TRANSFER_SELECTOR(): Selector {
-        return encodeSelector('transfer');
-    }
-
-    public static get TRANSFER_FROM_SELECTOR(): Selector {
-        return encodeSelector('transferFrom');
-    }
-
-    public static safeApprove(token: Address, spender: Address, amount: u256): void {
-        const calldata = new BytesWriter();
-        calldata.writeSelector(this.APPROVE_SELECTOR);
-        calldata.writeAddress(spender);
-        calldata.writeU256(amount);
-
-        const response = Blockchain.call(token, calldata);
-        const isOk = response.readBoolean();
-
-        if (!isOk) {
-            throw new Revert(`TransferHelper: APPROVE_FAILED`);
-        }
-    }
-
-    public static safeTransfer(token: Address, to: Address, amount: u256): void {
-        const calldata = new BytesWriter();
-        calldata.writeSelector(this.TRANSFER_SELECTOR);
-        calldata.writeAddress(to);
-        calldata.writeU256(amount);
-
-        const response = Blockchain.call(token, calldata);
-        const isOk = response.readBoolean();
-
-        if (!isOk) {
-            throw new Revert(`TransferHelper: TRANSFER_FAILED`);
-        }
-    }
-
-    public static safeTransferFrom(token: Address, from: Address, to: Address, amount: u256): void {
-        const calldata = new BytesWriter();
-        calldata.writeSelector(this.TRANSFER_FROM_SELECTOR);
-
-        calldata.writeAddress(from);
-        calldata.writeAddress(to);
-        calldata.writeU256(amount);
-
-        const response = Blockchain.call(token, calldata);
-        const isOk = response.readBoolean();
-
-        if (!isOk) {
-            throw new Revert(`TransferHelper: TRANSFER_FROM_FAILED`);
-        }
-    }
-}
+import { u256 } from 'as-bignum/assembly/integer/u256';
+import { encodeSelector, Selector } from '../math/abi';
+import { Address } from '../types/Address';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { Blockchain } from '../env';
+import { Revert } from '../types/Revert';
+
+export class TransferHelper {
+    public static get APPROVE_SELECTOR(): Selector {
+        return encodeSelector('approve');
+    }
+
+    public static get TRANSFER_SELECTOR(): Selector {
+        return encodeSelector('transfer');
+    }
+
+    public static get TRANSFER_FROM_SELECTOR(): Selector {
+        return encodeSelector('transferFrom');
+    }
+
+    public static safeApprove(token: Address, spender: Address, amount: u256): void {
+        const calldata = new BytesWriter();
+        calldata.writeSelector(this.APPROVE_SELECTOR);
+        calldata.writeAddress(spender);
+        calldata.writeU256(amount);
+
+        const response = Blockchain.call(token, calldata);
+        const isOk = response.readBoolean();
+
+        if (!isOk) {
+            throw new Revert(`TransferHelper: APPROVE_FAILED`);
+        }
+    }
+
+    public static safeTransfer(token: Address, to: Address, amount: u256): void {
+        const calldata = new BytesWriter();
+        calldata.writeSelector(this.TRANSFER_SELECTOR);
+        calldata.writeAddress(to);
+        calldata.writeU256(amount);
+
+        const response = Blockchain.call(token, calldata);
+        const isOk = response.readBoolean();
+
+        if (!isOk) {
+            throw new Revert(`TransferHelper: TRANSFER_FAILED`);
+        }
+    }
+
+    public static safeTransferFrom(token: Address, from: Address, to: Address, amount: u256): void {
+        const calldata = new BytesWriter();
+        calldata.writeSelector(this.TRANSFER_FROM_SELECTOR);
+
+        calldata.writeAddress(from);
+        calldata.writeAddress(to);
+        calldata.writeU256(amount);
+
+        const response = Blockchain.call(token, calldata);
+        const isOk = response.readBoolean();
+
+        if (!isOk) {
+            throw new Revert(`TransferHelper: TRANSFER_FROM_FAILED`);
+        }
+    }
+}

package/runtime/storage/Serializable.ts

@@ -3,6 +3,7 @@ import { Blockchain } from '../env';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { BytesReader } from '../buffer/BytesReader';
+import { Revert } from '../types/Revert';
 
 export abstract class Serializable {
     protected pointer: u16;
@@ -15,7 +16,6 @@ export abstract class Serializable {
     }
 
     public abstract get chunkCount(): i32;
-    public abstract get length(): i32;
     public abstract writeToBuffer(): BytesWriter;
     public abstract readFromBuffer(reader: BytesReader): void;
 
@@ -60,7 +60,11 @@ export abstract class Serializable {
     }
 
     protected chunksToBytes(chunks: u256[]): BytesReader {
-        const buffer: Uint8Array = new Uint8Array(this.length);
+        if(this.chunkCount >= 67108863) {
+            throw new Revert('Too many chunks received');
+        }
+
+        const buffer: Uint8Array = new Uint8Array(this.chunkCount * 32);
         let offset: i32 = 0;
 
         for (let indexChunk: i32 = 0; indexChunk < chunks.length; indexChunk++) {

package/runtime/storage/StoredBoolean.ts

@@ -0,0 +1,48 @@
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+
+@final
+export class StoredBoolean {
+    constructor(
+        public pointer: u16,
+        private defaultValue: bool,
+    ) {}
+
+    private _value: u256 = u256.Zero;
+
+    @inline
+    public get value(): bool {
+        this.ensureValue();
+
+        return this._value.toBool();
+    }
+
+    @inline
+    public set value(value: bool) {
+        this._value = value ? u256.One : u256.Zero;
+
+        Blockchain.setStorageAt(this.pointer, u256.Zero, this._value);
+    }
+
+    @inline
+    public set(value: u256): this {
+        this._value = value;
+
+        Blockchain.setStorageAt(this.pointer, u256.Zero, this._value);
+
+        return this;
+    }
+
+    @inline
+    public toUint8Array(): Uint8Array {
+        return this._value.toUint8Array(true);
+    }
+
+    private ensureValue(): void {
+        this._value = Blockchain.getStorageAt(
+            this.pointer,
+            u256.Zero,
+            this.defaultValue ? u256.One : u256.Zero,
+        );
+    }
+}