@btc-vision/btc-runtime 1.2.5 → 1.2.6

package/package.json

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

package/runtime/env/BlockchainEnvironment.ts

@@ -3,7 +3,6 @@ import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { MemorySlotData } from '../memory/MemorySlot';
 import { u256 } from 'as-bignum/assembly';
 import { BytesReader } from '../buffer/BytesReader';
-import { encodePointerHash } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { NetEvent } from '../events/NetEvent';
 import { Potential } from '../lang/Definitions';
@@ -210,11 +209,9 @@ export class BlockchainEnvironment {
     }
 
     public getStorageAt(
-        pointer: u16,
-        subPointer: MemorySlotPointer,
+        pointerHash: MemorySlotPointer,
         defaultValue: MemorySlotData<u256>,
     ): MemorySlotData<u256> {
-        const pointerHash: MemorySlotPointer = encodePointerHash(pointer, subPointer);
         this.ensureStorageAtPointer(pointerHash, defaultValue);
 
         if (this.storage.has(pointerHash)) {
@@ -224,20 +221,14 @@ export class BlockchainEnvironment {
         return defaultValue;
     }
 
-    public hasStorageAt(pointer: u16, subPointer: MemorySlotPointer): bool {
+    public hasStorageAt(pointerHash: MemorySlotPointer): bool {
         // We mark zero as the default value for the storage, if something is 0, the storage slot get deleted or is non-existent
-        const val: u256 = this.getStorageAt(pointer, subPointer, u256.Zero);
+        const val: u256 = this.getStorageAt(pointerHash, u256.Zero);
 
         return u256.ne(val, u256.Zero);
     }
 
-    public setStorageAt(
-        pointer: u16,
-        keyPointer: MemorySlotPointer,
-        value: MemorySlotData<u256>,
-    ): void {
-        const pointerHash: u256 = encodePointerHash(pointer, keyPointer);
-
+    public setStorageAt(pointerHash: MemorySlotPointer, value: MemorySlotData<u256>): void {
         this._internalSetStorageAt(pointerHash, value);
     }
 

package/runtime/math/abi.ts

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

@@ -3,6 +3,7 @@ import { Blockchain } from '../env';
 import { encodePointer } from '../math/abi';
 import { MemorySlotData } from './MemorySlot';
 import { u256 } from 'as-bignum/assembly';
+import { BytesWriter } from '../buffer/BytesWriter';
 
 @final
 export class AddressMemoryMap<K extends string, V extends MemorySlotData<u256>> {
@@ -16,18 +17,22 @@ export class AddressMemoryMap<K extends string, V extends MemorySlotData<u256>>
     }
 
     public set(key: K, value: V): this {
-        const keyHash: MemorySlotPointer = encodePointer(key);
-        Blockchain.setStorageAt(this.pointer, keyHash, value);
+        const keyHash: MemorySlotPointer = this.encodePointer(key);
+        Blockchain.setStorageAt(keyHash, value);
 
         return this;
     }
 
     public get(key: K): MemorySlotData<u256> {
-        return Blockchain.getStorageAt(this.pointer, encodePointer(key), this.defaultValue);
+        const keyHash: MemorySlotPointer = this.encodePointer(key);
+
+        return Blockchain.getStorageAt(keyHash, this.defaultValue);
     }
 
     public has(key: K): bool {
-        return Blockchain.hasStorageAt(this.pointer, encodePointer(key));
+        const keyHash: MemorySlotPointer = this.encodePointer(key);
+
+        return Blockchain.hasStorageAt(keyHash);
     }
 
     @unsafe
@@ -41,4 +46,12 @@ export class AddressMemoryMap<K extends string, V extends MemorySlotData<u256>>
     public clear(): void {
         throw new Error('Method not implemented.');
     }
+
+    private encodePointer(key: K): MemorySlotPointer {
+        const writer = new BytesWriter(key.length + 2);
+        writer.writeU16(this.pointer);
+        writer.writeString(key);
+
+        return encodePointer(writer.getBuffer());
+    }
 }

package/runtime/memory/KeyMerger.ts

@@ -3,6 +3,7 @@ import { u256 } from 'as-bignum/assembly';
 import { Blockchain } from '../env';
 import { MemorySlotPointer } from './MemorySlotPointer';
 import { encodePointer } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
 
 @final
 export class KeyMerger<K extends string, K2 extends string, V extends MemorySlotData<u256>> {
@@ -22,9 +23,9 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
 
     public set(key2: K2, value: V): this {
         const mergedKey: string = `${this.parentKey}${key2}`;
-        const keyHash: MemorySlotPointer = encodePointer(mergedKey);
+        const keyHash: MemorySlotPointer = this.encodePointer(mergedKey);
 
-        Blockchain.setStorageAt(this.pointer, keyHash, value);
+        Blockchain.setStorageAt(keyHash, value);
 
         return this;
     }
@@ -32,13 +33,13 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
     public get(key: K): MemorySlotData<u256> {
         const mergedKey: string = `${this.parentKey}${key}`;
 
-        return Blockchain.getStorageAt(this.pointer, encodePointer(mergedKey), this.defaultValue);
+        return Blockchain.getStorageAt(this.encodePointer(mergedKey), this.defaultValue);
     }
 
     public has(key: K): bool {
         const mergedKey: string = `${this.parentKey}${key}`;
 
-        return Blockchain.hasStorageAt(this.pointer, encodePointer(mergedKey));
+        return Blockchain.hasStorageAt(this.encodePointer(mergedKey));
     }
 
     @unsafe
@@ -50,4 +51,12 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
     public clear(): void {
         throw new Error('Clear method not implemented.');
     }
+
+    private encodePointer(key: string): MemorySlotPointer {
+        const writer = new BytesWriter(key.length + 2);
+        writer.writeU16(this.pointer);
+        writer.writeString(key);
+
+        return encodePointer(writer.getBuffer());
+    }
 }

package/runtime/storage/Serializable.ts

@@ -4,26 +4,29 @@ import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { BytesReader } from '../buffer/BytesReader';
 import { Revert } from '../types/Revert';
+import { encodePointer } from '../math/abi';
 
 export abstract class Serializable {
     protected pointer: u16;
-    protected subPointer:MemorySlotPointer;
+    protected subPointer: MemorySlotPointer;
 
-    protected constructor(pointer: u16,
-                          subPointer:MemorySlotPointer) {
+    protected constructor(pointer: u16, subPointer: MemorySlotPointer) {
         this.pointer = pointer;
         this.subPointer = subPointer;
     }
 
     public abstract get chunkCount(): i32;
+
     public abstract writeToBuffer(): BytesWriter;
+
     public abstract readFromBuffer(reader: BytesReader): void;
 
-    public load() :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);
+        for (let index: i32 = 0; index < this.chunkCount; index++) {
+            const pointer = this.getPointer(u256.add(this.subPointer, u256.fromU32(index)));
+            const chunk: u256 = Blockchain.getStorageAt(pointer, u256.Zero);
             chunks.push(chunk);
         }
 
@@ -41,8 +44,7 @@ export abstract class Serializable {
 
         for (let index: i32 = 0; index < chunks.length; index++) {
             Blockchain.setStorageAt(
-                this.pointer,
-                u256.add(this.subPointer, u256.fromU32(index)),
+                this.getPointer(u256.add(this.subPointer, u256.fromU32(index))),
                 chunks[index],
             );
         }
@@ -60,7 +62,7 @@ export abstract class Serializable {
     }
 
     protected chunksToBytes(chunks: u256[]): BytesReader {
-        if(this.chunkCount >= 67108863) {
+        if (this.chunkCount >= 67108863) {
             throw new Revert('Too many chunks received');
         }
 
@@ -76,4 +78,12 @@ export abstract class Serializable {
 
         return new BytesReader(buffer);
     }
+
+    private getPointer(subPointer: u256): u256 {
+        const writer = new BytesWriter(34);
+        writer.writeU16(this.pointer);
+        writer.writeU256(subPointer);
+
+        return encodePointer(writer.getBuffer());
+    }
 }

package/runtime/storage/StoredBoolean.ts

@@ -3,10 +3,14 @@ import { Blockchain } from '../env';
 
 @final
 export class StoredBoolean {
+    private readonly u256Pointer: u256;
+
     constructor(
         public pointer: u16,
         private defaultValue: bool,
-    ) {}
+    ) {
+        this.u256Pointer = u256.from(this.pointer);
+    }
 
     private _value: u256 = u256.Zero;
 
@@ -21,14 +25,14 @@ export class StoredBoolean {
     public set value(value: bool) {
         this._value = value ? u256.One : u256.Zero;
 
-        Blockchain.setStorageAt(this.pointer, u256.Zero, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
     }
 
     @inline
     public set(value: u256): this {
         this._value = value;
 
-        Blockchain.setStorageAt(this.pointer, u256.Zero, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -40,8 +44,7 @@ export class StoredBoolean {
 
     private ensureValue(): void {
         this._value = Blockchain.getStorageAt(
-            this.pointer,
-            u256.Zero,
+            this.u256Pointer,
             this.defaultValue ? u256.One : u256.Zero,
         );
     }

package/runtime/storage/StoredString.ts

@@ -1,6 +1,8 @@
 import { u256 } from 'as-bignum/assembly';
 import { Blockchain } from '../env';
 import { SafeMath } from '../types/SafeMath';
+import { encodePointer } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
 
 @final
 export class StoredString {
@@ -30,8 +32,12 @@ export class StoredString {
         return a < b ? a : b;
     }
 
-    private max(a: u32, b: u32): u32 {
-        return a > b ? a : b;
+    private getPointer(key: u256): u256 {
+        const buf = new BytesWriter(34);
+        buf.writeU16(this.pointer);
+        buf.writeU256(key);
+
+        return encodePointer(buf.getBuffer());
     }
 
     private save(): void {
@@ -55,7 +61,7 @@ export class StoredString {
         // Save the initial chunk (first 28 bytes) in the header
         let bytesToWrite: u32 = this.min(remainingLength, 28);
         header = this.saveChunk(header, this._value, offset, bytesToWrite, 4);
-        Blockchain.setStorageAt(this.pointer, currentPointer, header);
+        Blockchain.setStorageAt(this.getPointer(currentPointer), header);
 
         remainingLength -= bytesToWrite;
         offset += bytesToWrite;
@@ -71,7 +77,7 @@ export class StoredString {
                 0,
             );
             currentPointer = u256.add(currentPointer, u256.One);
-            Blockchain.setStorageAt(this.pointer, currentPointer, storageValue);
+            Blockchain.setStorageAt(this.getPointer(currentPointer), storageValue);
 
             remainingLength -= bytesToWrite;
             offset += bytesToWrite;
@@ -95,7 +101,7 @@ export class StoredString {
     }
 
     private load(): void {
-        const header: u256 = Blockchain.getStorageAt(this.pointer, u256.Zero, u256.Zero);
+        const header: u256 = Blockchain.getStorageAt(this.getPointer(u256.Zero), u256.Zero);
         if (u256.eq(header, u256.Zero)) {
             if (this.defaultValue) {
                 this.value = this.defaultValue;
@@ -120,7 +126,7 @@ export class StoredString {
         while (remainingLength > 0) {
             // Move to the next storage slot
             currentPointer = u256.add(currentPointer, u256.One);
-            currentStorage = Blockchain.getStorageAt(this.pointer, currentPointer, u256.Zero);
+            currentStorage = Blockchain.getStorageAt(this.getPointer(currentPointer), u256.Zero);
 
             // Extract the relevant portion of the string from the current storage slot
             const bytesToRead: u32 = this.min(remainingLength, 32);

package/runtime/storage/StoredU256.ts

@@ -2,14 +2,24 @@ import { u256 } from 'as-bignum/assembly';
 import { SafeMath } from '../types/SafeMath';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { Blockchain } from '../env';
+import { encodePointer } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
 
 @final
 export class StoredU256 {
+    private readonly u256Pointer: u256;
+
     constructor(
         public pointer: u16,
         public subPointer: MemorySlotPointer,
         private defaultValue: u256,
-    ) {}
+    ) {
+        const writer = new BytesWriter(34);
+        writer.writeU16(pointer);
+        writer.writeU256(subPointer);
+
+        this.u256Pointer = encodePointer(writer.getBuffer());
+    }
 
     private _value: u256 = u256.Zero;
 
@@ -28,7 +38,7 @@ export class StoredU256 {
 
         this._value = value;
 
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
     }
 
     @inline
@@ -42,7 +52,28 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
+
+        return this;
+    }
+
+    @inline
+    public addNoCommit(value: u256): this {
+        this._value = SafeMath.add(this._value, value);
+
+        return this;
+    }
+
+    @inline
+    public subNoCommit(value: u256): this {
+        this._value = SafeMath.sub(this._value, value);
+
+        return this;
+    }
+
+    @inline
+    public commit(): this {
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -53,7 +84,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -64,7 +95,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.mul(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -123,7 +154,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.shr(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -134,7 +165,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.and(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -145,7 +176,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.or(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -156,7 +187,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = u256.xor(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -167,7 +198,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.pow(this._value, exponent);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -178,7 +209,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.mod(this._value, value);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -189,7 +220,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.add(this._value, u256.One);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -200,7 +231,7 @@ export class StoredU256 {
         this.ensureValue();
 
         this._value = SafeMath.sub(this._value, u256.One);
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -209,7 +240,7 @@ export class StoredU256 {
     public set(value: u256): this {
         this._value = value;
 
-        Blockchain.setStorageAt(this.pointer, this.subPointer, this._value);
+        Blockchain.setStorageAt(this.u256Pointer, this._value);
 
         return this;
     }
@@ -220,6 +251,6 @@ export class StoredU256 {
     }
 
     private ensureValue(): void {
-        this._value = Blockchain.getStorageAt(this.pointer, this.subPointer, this.defaultValue);
+        this._value = Blockchain.getStorageAt(this.u256Pointer, this.defaultValue);
     }
 }