@btc-vision/btc-runtime 1.0.28 → 1.0.30

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/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

@@ -0,0 +1,75 @@
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { BytesReader } from '../buffer/BytesReader';
+
+export abstract class Serializable {
+    protected pointer: u16;
+    protected subPointer:MemorySlotPointer;
+
+    protected constructor(pointer: u16,
+                          subPointer:MemorySlotPointer) {
+        this.pointer = pointer;
+        this.subPointer = subPointer;
+    }
+
+    public abstract get chunkCount(): i32;
+    public abstract get length(): i32;
+    public abstract writeToBuffer(): BytesWriter;
+    public abstract readFromBuffer(reader: BytesReader): void;
+
+    public load() :void {
+        const chunks: u256[] = [];
+
+        for(let index:i32 = 0; index < this.chunkCount; index++){
+            const chunk: u256 = Blockchain.getStorageAt(this.pointer, u256.add(this.subPointer, u256.fromU32(index)), u256.Zero);
+            chunks.push(chunk);
+        }
+
+        const reader = this.chunksToBytes(chunks);
+
+        this.readFromBuffer(reader);
+    }
+
+    public save(): void {
+        const writer: BytesWriter = this.writeToBuffer();
+
+        const buffer = writer.getBuffer();
+
+        const chunks: u256[] = this.bytesToChunks(buffer);
+
+        for (let index: i32 = 0; index < chunks.length; index++) {
+            Blockchain.setStorageAt(
+                this.pointer,
+                u256.add(this.subPointer, u256.fromU32(index)),
+                chunks[index],
+            );
+        }
+    }
+
+    protected bytesToChunks(buffer: Uint8Array): u256[] {
+        const chunks: u256[] = [];
+
+        for (let index: i32 = 0; index < buffer.byteLength; index += 32) {
+            const chunk = buffer.slice(index, index + 32);
+            chunks.push(u256.fromBytes(chunk, true));
+        }
+
+        return chunks;
+    }
+
+    protected chunksToBytes(chunks: u256[]): BytesReader {
+        const buffer: Uint8Array = new Uint8Array(this.length);
+        let offset: i32 = 0;
+
+        for (let indexChunk: i32 = 0; indexChunk < chunks.length; indexChunk++) {
+            const bytes: u8[] = chunks[indexChunk].toBytes(true);
+            for (let indexByte: i32 = 0; indexByte < bytes.length; indexByte++) {
+                buffer[offset++] = bytes[indexByte];
+            }
+        }
+
+        return new BytesReader(buffer);
+    }
+}