@btc-vision/btc-runtime 1.0.16 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.0.16",
+    "version": "1.0.17",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "types": "btc/index.ts",

package/runtime/contracts/OP_20.ts

@@ -306,7 +306,9 @@ export abstract class OP_20 extends OP_NET implements IOP_20 {
         if (allowed < value) throw new Revert(`Insufficient allowance ${allowed} < ${value}`);
 
         const newAllowance: u256 = SafeMath.sub(allowed, value);
-        fromAllowanceMap.set(from, newAllowance);
+        fromAllowanceMap.set(spender, newAllowance);
+
+        this.allowanceMap.set(from, fromAllowanceMap);
 
         this._unsafeTransferFrom(from, to, value);
 

package/runtime/env/BTCEnvironment.ts

@@ -8,7 +8,6 @@ import { encodePointerHash } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { MAX_EVENTS, NetEvent } from '../events/NetEvent';
 import { Potential } from '../lang/Definitions';
-import { Map } from '../generic/Map';
 import { OP_NET } from '../contracts/OP_NET';
 import { PointerStorage } from '../types';
 import {
@@ -21,6 +20,7 @@ import {
     storePointer,
 } from './global';
 import { DeployContractResponse } from '../interfaces/DeployContractResponse';
+import { MapU256 } from '../generic/MapU256';
 
 export * from '../env/global';
 
@@ -28,7 +28,7 @@ export * from '../env/global';
 export class BlockchainEnvironment {
     private static readonly runtimeException: string = 'RuntimeException';
 
-    private storage: PointerStorage = new Map();
+    private storage: PointerStorage = new MapU256();
     private events: NetEvent[] = [];
 
     private _callee: PotentialAddress = null;
@@ -226,14 +226,8 @@ export class BlockchainEnvironment {
         const pointerHash: MemorySlotPointer = encodePointerHash(pointer, subPointer);
         this.ensureStorageAtPointer(pointerHash, defaultValue);
 
-        // maybe find a better way for this
-        const allKeys: u256[] = this.storage.keys();
-        for (let i: i32 = 0; i < allKeys.length; i++) {
-            const v: u256 = allKeys[i];
-
-            if (u256.eq(v, pointerHash)) {
-                return this.storage.get(v);
-            }
+        if (this.storage.has(pointerHash)) {
+            return this.storage.get(pointerHash);
         }
 
         return defaultValue;
@@ -272,17 +266,6 @@ export class BlockchainEnvironment {
     }
 
     private _internalSetStorageAt(pointerHash: u256, value: MemorySlotData<u256>): void {
-        const keys: u256[] = this.storage.keys();
-
-        // Delete the old value, there is a bug with u256 and maps.
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-
-            if (u256.eq(key, pointerHash)) {
-                this.storage.delete(key);
-            }
-        }
-
         this.storage.set(pointerHash, value);
 
         const writer: BytesWriter = new BytesWriter();
@@ -294,14 +277,8 @@ export class BlockchainEnvironment {
     }
 
     private hasPointerStorageHash(pointer: MemorySlotPointer): bool {
-        const keys = this.storage.keys();
-
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-
-            if (u256.eq(key, pointer)) {
-                return true;
-            }
+        if (this.storage.has(pointer)) {
+            return true;
         }
 
         // we attempt to load the requested pointer.

package/runtime/generic/Map.ts

@@ -1,8 +1,8 @@
 import { Revert } from '../types/Revert';
 
 export class Map<K, V> {
-    private _keys: K[] = [];
-    private _values: V[] = [];
+    protected _keys: K[] = [];
+    protected _values: V[] = [];
 
     public get size(): i32 {
         return this._keys.length;
@@ -17,7 +17,7 @@ export class Map<K, V> {
     }
 
     public set(key: K, value: V): void {
-        const index: i32 = this._keys.indexOf(key);
+        const index: i32 = this.indexOf(key);
         if (index == -1) {
             this._keys.push(key);
             this._values.push(value);
@@ -26,8 +26,12 @@ export class Map<K, V> {
         }
     }
 
+    public indexOf(key: K): i32 {
+        return this._keys.indexOf(key);
+    }
+
     public get(key: K): V {
-        const index: i32 = this._keys.indexOf(key);
+        const index: i32 = this.indexOf(key);
         if (index == -1) {
             throw new Revert('Key not found in map');
         }
@@ -35,11 +39,17 @@ export class Map<K, V> {
     }
 
     public has(key: K): bool {
-        return this._keys.includes(key);
+        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._keys.indexOf(key);
+        const index: i32 = this.indexOf(key);
         if (index == -1) {
             return false;
         }

package/runtime/generic/MapU256.ts

@@ -0,0 +1,58 @@
+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 {
+        // Delete the old value
+        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;
+    }
+}