@btc-vision/btc-runtime 1.3.7 → 1.3.9

package/package.json

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

package/runtime/buffer/BytesReader.ts

@@ -3,7 +3,6 @@ import { Selector } from '../math/abi';
 import { i128, u128, u256 } from 'as-bignum/assembly';
 import { Revert } from '../types/Revert';
 import { TransactionInput, TransactionOutput } from '../env/classes/UTXO';
-import { StaticArray } from 'staticarray';
 import { i256 } from '../math/i256';
 import { AddressMap } from '../generic/AddressMap';
 
@@ -143,9 +142,9 @@ export class BytesReader {
         return String.UTF8.decode(bytes.buffer);
     }
 
-    public readTransactionInputs(): StaticArray<TransactionInput> {
+    public readTransactionInputs(): TransactionInput[] {
         const length = this.readU8();
-        const result = new StaticArray<TransactionInput>(length);
+        const result = new Array<TransactionInput>(length);
 
         for (let i: u16 = 0; i < length; i++) {
             const txId = this.readBytes(32);
@@ -158,13 +157,13 @@ export class BytesReader {
         return result;
     }
 
-    public readTransactionOutputs(): StaticArray<TransactionOutput> {
+    public readTransactionOutputs(): TransactionOutput[] {
         const length = this.readU8();
-        const result = new StaticArray<TransactionOutput>(length);
+        const result = new Array<TransactionOutput>(length);
 
         for (let i: u16 = 0; i < length; i++) {
             const index = this.readU8();
-            const scriptPubKey = this.readBytesWithLength();
+            const scriptPubKey = this.readStringWithLength();
             const value = this.readU64();
 
             result[i] = new TransactionOutput(index, scriptPubKey, value);
@@ -192,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

@@ -37,9 +37,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         super();
 
         this.allowanceMap = new MultiAddressMemoryMap<u256>(allowanceMapPointer, u256.Zero);
-
         this.balanceOfMap = new AddressMemoryMap<u256>(balanceOfMapPointer, u256.Zero);
-
         this._totalSupply = new StoredU256(totalSupplyPointer, u256.Zero, u256.Zero);
 
         this._maxSupply = new StoredU256(maxSupplyPointer, u256.Zero, 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/classes/Transaction.ts

@@ -1,7 +1,6 @@
 import { Address } from '../../types/Address';
 import { TransactionInput, TransactionOutput } from './UTXO';
 import { Potential } from '../../lang/Definitions';
-import { StaticArray } from 'staticarray';
 import { BytesReader } from '../../buffer/BytesReader';
 import { inputs, outputs } from '../global';
 
@@ -13,33 +12,39 @@ export class Transaction {
         public readonly id: Uint8Array,
     ) {}
 
-    private _inputs: Potential<StaticArray<TransactionInput>> = null;
+    private _inputs: Potential<TransactionInput[]> = null;
 
-    public get inputs(): StaticArray<TransactionInput> {
+    public get inputs(): TransactionInput[] {
         if (!this._inputs) {
-            this._inputs = this.loadInputs();
+            const inputs = this.loadInputs();
+            this._inputs = inputs;
+
+            return inputs;
         }
 
-        return this._inputs;
+        return this._inputs as TransactionInput[];
     }
 
-    private _outputs: Potential<StaticArray<TransactionOutput>> = null;
+    private _outputs: Potential<TransactionOutput[]> = null;
 
-    public get outputs(): StaticArray<TransactionOutput> {
+    public get outputs(): TransactionOutput[] {
         if (!this._outputs) {
-            this._outputs = this.loadOutputs();
+            const outputs = this.loadOutputs();
+            this._outputs = outputs;
+
+            return outputs;
         }
 
-        return this._outputs;
+        return this._outputs as TransactionOutput[];
     }
 
-    private loadInputs(): StaticArray<TransactionInput> {
+    private loadInputs(): TransactionInput[] {
         const buffer = new BytesReader(inputs());
 
         return buffer.readTransactionInputs();
     }
 
-    private loadOutputs(): StaticArray<TransactionOutput> {
+    private loadOutputs(): TransactionOutput[] {
         const buffer = new BytesReader(outputs());
 
         return buffer.readTransactionOutputs();

package/runtime/env/classes/UTXO.ts

@@ -11,7 +11,7 @@ export class TransactionInput {
 export class TransactionOutput {
     public constructor(
         public readonly index: u8,
-        public readonly scriptPubKey: Uint8Array,
+        public readonly to: string,
         public readonly value: u64,
     ) {}
 }

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);
 }