@btc-vision/btc-runtime 1.3.6 → 1.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.3.6",
+    "version": "1.3.8",
     "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);

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/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/storage/StoredBoolean.ts

@@ -9,7 +9,7 @@ export class StoredBoolean {
         public pointer: u16,
         private defaultValue: bool,
     ) {
-        this.u256Pointer = u256.from(this.pointer);
+        this.u256Pointer = u256.from(pointer);
     }
 
     private _value: u256 = u256.Zero;

package/runtime/types/SafeMath.ts

@@ -27,7 +27,6 @@ export class SafeMath {
         return SafeMath.mod(mul, modulus);
     }
 
-    @inline
     @unsafe
     @operator('%')
     public static mod(a: u256, b: u256): u256 {
@@ -66,15 +65,14 @@ export class SafeMath {
 
     public static pow(base: u256, exponent: u256): u256 {
         let result: u256 = u256.One;
-        while (exponent > u256.Zero) {
-            if (u256.and(exponent, u256.One)) {
+        while (u256.gt(exponent, u256.Zero)) {
+            if (u256.ne(u256.and(exponent, u256.One), u256.Zero)) {
                 result = SafeMath.mul(result, base);
             }
 
             base = SafeMath.mul(base, base);
             exponent = u256.shr(exponent, 1);
         }
-
         return result;
     }
 
@@ -93,7 +91,6 @@ export class SafeMath {
         return c;
     }
 
-    @inline
     @unsafe
     @operator('/')
     public static div(a: u256, b: u256): u256 {
@@ -139,7 +136,6 @@ export class SafeMath {
         return u256.gt(a, b) ? a : b;
     }
 
-    @inline
     @unsafe
     public static sqrt(y: u256): u256 {
         if (u256.gt(y, u256.fromU32(3))) {
@@ -167,7 +163,6 @@ export class SafeMath {
         }
     }
 
-    @inline
     @unsafe
     public static shl(value: u256, shift: i32): u256 {
         if (shift == 0) {
@@ -225,8 +220,26 @@ export class SafeMath {
      * @param value The value to increment
      * @returns The incremented value
      */
-    @inline
     static inc(value: u256): u256 {
         return value.preInc();
     }
+
+    /**
+     * Approximates the binary logarithm (log2) of a u256 integer.
+     * @param x - The input value for which to calculate log2(x).
+     * @returns The approximate log2(x) as u256.
+     */
+    @unsafe
+    public static approximateLog2(x: u256): u256 {
+        // Count the position of the highest bit set
+        let n: u256 = u256.Zero;
+        let value = x;
+
+        while (u256.gt(value, u256.One)) {
+            value = u256.shr(value, 1);
+            n = SafeMath.add(n, u256.One);
+        }
+
+        return n;
+    }
 }