@btc-vision/btc-runtime 1.3.8 → 1.3.10

package/package.json

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

package/runtime/buffer/BytesReader.ts

@@ -191,6 +191,17 @@ export class BytesReader {
         return result;
     }
 
+    public readU128Array(): u128[] {
+        const length = this.readU16();
+        const result: u128[] = new Array<u128>(length);
+
+        for (let i: u16 = 0; i < length; i++) {
+            result[i] = this.readU128();
+        }
+
+        return result;
+    }
+
     public readAddressValueTuple(): AddressMap<u256> {
         const length: u16 = this.readU16();
         const result = new AddressMap<u256>();

package/runtime/buffer/BytesWriter.ts

@@ -73,6 +73,10 @@ export class BytesWriter {
         }
     }
 
+    public writeU8At(value: u8, offset: u32): void {
+        this.buffer.setUint8(offset, value);
+    }
+
     public writeU256(value: u256): void {
         this.allocSafe(32);
 
@@ -92,10 +96,10 @@ export class BytesWriter {
     }
 
     public writeU128(value: u128): void {
-        this.allocSafe(32);
+        this.allocSafe(16);
 
         const bytes = value.toUint8Array(true);
-        for (let i: i32 = 0; i < 32; i++) {
+        for (let i: i32 = 0; i < 16; i++) {
             this.writeU8(bytes[i] || 0);
         }
     }
@@ -109,6 +113,17 @@ export class BytesWriter {
         }
     }
 
+    public writeU128Array(value: u128[]): void {
+        if (value.length > 65535) throw new Revert('Array size is too large');
+
+        this.allocSafe(2 + value.length * 16);
+        this.writeU32(u16(value.length));
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeU128(value[i]);
+        }
+    }
+
     public writeBytes(value: Uint8Array): void {
         this.allocSafe(value.length);
 

package/runtime/contracts/DeployableOP_20.ts

@@ -284,7 +284,6 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     protected _transfer(to: Address, value: u256): boolean {
         const sender = Blockchain.tx.sender;
 
-        if (!this.balanceOfMap.has(sender)) throw new Revert();
         if (this.isSelf(sender)) throw new Revert('Can not transfer from self account');
 
         if (u256.eq(value, u256.Zero)) {

package/runtime/contracts/OP_NET.ts

@@ -18,6 +18,8 @@ export class OP_NET implements IBTC {
 
     public onDeployment(_calldata: Calldata): void {}
 
+    public onExecutionCompleted(): void {}
+
     public execute(method: Selector, _calldata: Calldata): BytesWriter {
         let response: BytesWriter;
 

package/runtime/env/BlockchainEnvironment.ts

@@ -19,6 +19,7 @@ import {
     nextPointerGreaterThan,
     storePointer,
     validateBitcoinAddress,
+    verifySchnorrSignature,
 } from './global';
 import { DeployContractResponse } from '../interfaces/DeployContractResponse';
 import { MapU256 } from '../generic/MapU256';
@@ -248,6 +249,22 @@ export class BlockchainEnvironment {
         return reader.readU256();
     }
 
+    public verifySchnorrSignature(
+        publicKey: Address,
+        signature: Uint8Array,
+        hash: Uint8Array,
+    ): boolean {
+        const writer = new BytesWriter(128);
+        writer.writeBytes(publicKey);
+        writer.writeBytes(signature);
+        writer.writeBytes(hash);
+
+        const result: Uint8Array = verifySchnorrSignature(writer.getBuffer());
+
+        const reader = new BytesReader(result);
+        return reader.readBoolean();
+    }
+
     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(pointerHash, u256.Zero);

package/runtime/env/global.ts

@@ -53,3 +53,7 @@ export declare function inputs(): Uint8Array;
 // @ts-ignore
 @external('env', 'outputs')
 export declare function outputs(): Uint8Array;
+
+// @ts-ignore
+@external('env', 'verifySchnorrSignature')
+export declare function verifySchnorrSignature(data: Uint8Array): Uint8Array;

package/runtime/exports/index.ts

@@ -9,6 +9,8 @@ export function execute(data: Uint8Array): Uint8Array {
     const selector: Selector = calldata.readSelector();
     const result: BytesWriter = Blockchain.contract.execute(selector, calldata);
 
+    Blockchain.contract.onExecutionCompleted();
+
     return result.getBuffer();
 }
 

package/runtime/index.ts

@@ -46,6 +46,7 @@ export * from './math/cyrb53';
 export * from './math/sha256';
 export * from './math/rnd';
 export * from './math/i256';
+//export * from './math/u160'; Broken at the moment
 export * from './secp256k1/ECPoint';
 
 /** Memory */
@@ -60,6 +61,10 @@ export * from './memory/Uint8ArrayMerger';
 
 /** Storage */
 export * from './storage/StoredU256';
+export * from './storage/StoredU64';
+export * from './storage/StoredU16Array';
+export * from './storage/StoredU128Array';
+export * from './storage/StoredU256Array';
 export * from './storage/StoredString';
 export * from './storage/StoredAddress';
 export * from './storage/StoredBoolean';

package/runtime/math/abi.ts

@@ -13,7 +13,7 @@ export function encodeSelector(name: string): Selector {
 }
 
 export function encodePointer(uniqueIdentifier: u16, typed: Uint8Array): MemorySlotPointer {
-    const hash = Sha256.hash(typed);
+    const hash: Uint8Array = typed.length !== 32 ? Sha256.hash(typed) : typed;
 
     const finalPointer = new Uint8Array(32);
     finalPointer[0] = uniqueIdentifier & 0xff;

package/runtime/math/bytes.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly';
+import { u128, u256 } from 'as-bignum/assembly';
 
 export function bytes(number: u256[]): Uint8Array {
     const result = new Uint8Array(32 * number.length);
@@ -29,6 +29,15 @@ export function bytes8(number: Uint8Array): u64 {
     );
 }
 
+export function bytes16(buffer: Uint8Array): u128 {
+    // Make sure that the buffer is 16 bytes long.
+    if (buffer.length !== 16) {
+        buffer = buffer.slice(0, 16);
+    }
+
+    return u128.fromBytes(buffer);
+}
+
 export function bytes32(number: Uint8Array): u256 {
     return u256.fromBytes(number);
 }