@btc-vision/btc-runtime 1.5.8 → 1.6.0

package/package.json

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

package/runtime/contracts/DeployableOP_20.ts

@@ -279,13 +279,14 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
 
         // Build the hash to match exactly what the user signed, including the nonce
         const writer = new BytesWriter(
-            ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH + U256_BYTE_LENGTH,
+            ADDRESS_BYTE_LENGTH * 3 + U256_BYTE_LENGTH + U256_BYTE_LENGTH,
         );
 
         writer.writeAddress(owner);
         writer.writeAddress(spender);
         writer.writeU256(value);
         writer.writeU256(nonce);
+        writer.writeAddress(this.address);
 
         const hash = sha256(writer.getBuffer());
         if (!Blockchain.verifySchnorrSignature(owner, signature, hash)) {

package/runtime/env/BlockchainEnvironment.ts

@@ -15,11 +15,15 @@ import {
     env_exit,
     getCallResult,
     loadPointer,
+    tLoadPointer,
     log,
     sha256,
     storePointer,
+    tStorePointer,
     validateBitcoinAddress,
     verifySchnorrSignature,
+    getAccountType,
+    getBlockHash,
 } from './global';
 import { eqUint, MapUint8Array } from '../generic/MapUint8Array';
 import { EMPTY_BUFFER } from '../math/bytes';
@@ -36,6 +40,7 @@ export class BlockchainEnvironment {
     public readonly DEAD_ADDRESS: Address = Address.dead();
 
     private storage: MapUint8Array = new MapUint8Array();
+    private transientStorage: MapUint8Array = new MapUint8Array();
     private _selfContract: Potential<OP_NET> = null;
     private _plugins: Plugin[] = [];
 
@@ -230,6 +235,7 @@ export class BlockchainEnvironment {
             resultAddressBuffer,
         );
 
+        // TODO: Decode revert data if status is not 0
         if (status !== 0) {
             throw new Revert('Failed to deploy contract');
         }
@@ -249,6 +255,17 @@ export class BlockchainEnvironment {
         return new Uint8Array(32);
     }
 
+    public getTransientStorageAt(
+        pointerHash: Uint8Array,
+    ): Uint8Array {
+        this.hasPointerTransientStorageHash(pointerHash);
+        if (this.transientStorage.has(pointerHash)) {
+            return this.transientStorage.get(pointerHash);
+        }
+
+        return new Uint8Array(32);
+    }
+
     public sha256(buffer: Uint8Array): Uint8Array {
         return sha256(buffer);
     }
@@ -274,10 +291,21 @@ export class BlockchainEnvironment {
         return !eqUint(val, EMPTY_BUFFER);
     }
 
+    public hasTransientStorageAt(pointerHash: Uint8Array): 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: Uint8Array = this.getTransientStorageAt(pointerHash);
+
+        return !eqUint(val, EMPTY_BUFFER);
+    }
+
     public setStorageAt(pointerHash: Uint8Array, value: Uint8Array): void {
         this._internalSetStorageAt(pointerHash, value);
     }
 
+    public setTransientStorageAt(pointerHash: Uint8Array, value: Uint8Array): void {
+        this._internalSetTransientStorageAt(pointerHash, value);
+    }
+
     private createContractIfNotExists(): void {
         if (!this._contract) {
             throw new Revert('Contract is required');
@@ -294,6 +322,12 @@ export class BlockchainEnvironment {
         storePointer(pointerHash.buffer, value.buffer);
     }
 
+    private _internalSetTransientStorageAt(pointerHash: Uint8Array, value: Uint8Array): void {
+        this.transientStorage.set(pointerHash, value);
+
+        tStorePointer(pointerHash.buffer, value.buffer);
+    }
+
     private hasPointerStorageHash(pointer: Uint8Array): bool {
         if (this.storage.has(pointer)) {
             return true;
@@ -308,4 +342,29 @@ export class BlockchainEnvironment {
 
         return !eqUint(value, EMPTY_BUFFER);
     }
+
+    private hasPointerTransientStorageHash(pointer: Uint8Array): bool {
+        if (this.storage.has(pointer)) {
+            return true;
+        }
+
+        // we attempt to load the requested pointer.
+        const resultBuffer = new ArrayBuffer(32);
+        tLoadPointer(pointer.buffer, resultBuffer);
+
+        const value: Uint8Array = Uint8Array.wrap(resultBuffer);
+        this.storage.set(pointer, value); // cache the value
+
+        return !eqUint(value, EMPTY_BUFFER);
+    }
+
+    public getAccountType(address: Address): u32 {
+        return getAccountType(address.buffer)
+    }
+
+    public getBlockHash(blockNumber: u64): Uint8Array {
+        const hash = new ArrayBuffer(32);
+        getBlockHash(blockNumber, hash);
+        return Uint8Array.wrap(hash);
+    }
 }

package/runtime/env/global.ts

@@ -10,14 +10,18 @@ export declare function getCalldata(offset: u32, length: u32, result: ArrayBuffe
 @external('env', 'load')
 export declare function loadPointer(key: ArrayBuffer, result: ArrayBuffer): void;
 
-// @ts-ignore
-@external('env', 'nextPointerGreaterThan')
-export declare function nextPointerGreaterThan(data: Uint8Array): Uint8Array;
-
 // @ts-ignore
 @external('env', 'store')
 export declare function storePointer(key: ArrayBuffer, value: ArrayBuffer): void;
 
+// @ts-ignore
+@external('env', 'tload')
+export declare function tLoadPointer(key: ArrayBuffer, result: ArrayBuffer): void;
+
+// @ts-ignore
+@external('env', 'tstore')
+export declare function tStorePointer(key: ArrayBuffer, value: ArrayBuffer): void;
+
 // @ts-ignore
 @external('env', 'deployFromAddress')
 export declare function deployFromAddress(originAddress: ArrayBuffer, salt: ArrayBuffer, calldata: ArrayBuffer, calldataLength: u32, resultAddress: ArrayBuffer): u32;
@@ -83,6 +87,14 @@ export declare function getOutputsSize(): u32;
 @external('env', 'verifySchnorrSignature')
 export declare function verifySchnorrSignature(publicKey: ArrayBuffer, signature: ArrayBuffer, message: ArrayBuffer): u32;
 
+// @ts-ignore
+@external('env', 'blockHash')
+export declare function getBlockHash(block_number: u64, result: ArrayBuffer): void;
+
+// @ts-ignore
+@external('env', 'accountType')
+export declare function getAccountType(address: ArrayBuffer): u32;
+
 // @ts-ignore
 @external('env', 'exit')
 export declare function env_exit(status: u32, data: ArrayBuffer, dataLength: u32): void;