@btc-vision/btc-runtime 1.4.3 → 1.4.5

package/package.json

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

package/runtime/buffer/BytesReader.ts

@@ -2,13 +2,11 @@ import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
 import { TransactionInput, TransactionOutput } from '../env/classes/UTXO';
 import { AddressMap } from '../generic/AddressMap';
 import { Selector } from '../math/abi';
-import { i256 } from '../math/i256';
 import { Address } from '../types/Address';
 import { Revert } from '../types/Revert';
 import {
     ADDRESS_BYTE_LENGTH,
     I128_BYTE_LENGTH,
-    I256_BYTE_LENGTH,
     I64_BYTE_LENGTH,
     U128_BYTE_LENGTH,
     U16_BYTE_LENGTH,
@@ -16,7 +14,7 @@ import {
     U32_BYTE_LENGTH,
     U64_BYTE_LENGTH,
     U8_BYTE_LENGTH,
-} from '../utils/lengths';
+} from '../utils';
 
 @final
 export class BytesReader {
@@ -187,14 +185,6 @@ export class BytesReader {
         return result;
     }
 
-    public readI256(): i256 {
-        this.verifyEnd(this.currentOffset + I256_BYTE_LENGTH);
-
-        const next32Bytes: u8[] = this.readBytesBE(I256_BYTE_LENGTH);
-
-        return i256.fromBytesBE(next32Bytes);
-    }
-
     public readTuple(): u256[] {
         const length = this.readU32();
         const result: u256[] = new Array<u256>(length);

package/runtime/buffer/BytesWriter.ts

@@ -2,20 +2,18 @@ import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
 import { ArrayBuffer } from 'arraybuffer';
 import { AddressMap } from '../generic/AddressMap';
 import { Selector } from '../math/abi';
-import { i256 } from '../math/i256';
 import { Address } from '../types/Address';
 import { Revert } from '../types/Revert';
 import {
     ADDRESS_BYTE_LENGTH,
     I128_BYTE_LENGTH,
-    I256_BYTE_LENGTH,
     U128_BYTE_LENGTH,
     U16_BYTE_LENGTH,
     U256_BYTE_LENGTH,
     U32_BYTE_LENGTH,
     U64_BYTE_LENGTH,
     U8_BYTE_LENGTH,
-} from '../utils/lengths';
+} from '../utils';
 import { BytesReader } from './BytesReader';
 
 @final
@@ -76,15 +74,6 @@ export class BytesWriter {
         this.writeU8(value ? 1 : 0);
     }
 
-    public writeI256(value: i256): void {
-        this.allocSafe(I256_BYTE_LENGTH);
-
-        const bytes = value.toUint8Array(true);
-        for (let i: i32 = 0; i < I256_BYTE_LENGTH; i++) {
-            this.writeU8(bytes[i] || 0);
-        }
-    }
-
     public writeU8At(value: u8, offset: u32): void {
         this.buffer.setUint8(offset, value);
     }

package/runtime/index.ts

@@ -38,6 +38,7 @@ export * from './lang/Definitions';
 export * from './types/Address';
 export * from './types/Revert';
 export * from './types/SafeMath';
+export * from './types/SafeMathI128';
 
 /** Math */
 export * from './math/abi';
@@ -45,8 +46,6 @@ export * from './math/bytes';
 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 */

package/runtime/types/SafeMathI128.ts

@@ -0,0 +1,146 @@
+import { i128 } from '@btc-vision/as-bignum/assembly';
+
+export class SafeMathI128 {
+    public static readonly ZERO: i128 = i128.fromI32(0);
+    public static readonly ONE: i128 = i128.fromI32(1);
+    public static readonly NEG_ONE: i128 = i128.fromI32(-1);
+
+    public static readonly MIN: i128 = i128.Min;
+    public static readonly MAX: i128 = i128.Max;
+
+    /**
+     * Safe addition for i128.
+     * Throws if (a + b) overflows or underflows the signed 128-bit range.
+     */
+    public static add(a: i128, b: i128): i128 {
+        let c = i128.add(a, b);
+
+        // Overflow check for 2's complement:
+        // If a and b have the same sign, but c differs, overflow occurred.
+        // We can detect sign mismatch using ((a ^ c) & (b ^ c)) < 0
+        // (i.e., the sign bit is set in that expression).
+        if (((a ^ c) & (b ^ c)).isNeg()) {
+            throw new Error('SafeMathI128: addition overflow');
+        }
+
+        return c;
+    }
+
+    /**
+     * Safe subtraction for i128.
+     * Throws if (a - b) overflows or underflows the signed 128-bit range.
+     */
+    public static sub(a: i128, b: i128): i128 {
+        let c = i128.sub(a, b);
+
+        // Subtraction is (a + (-b)). We can do a direct check like:
+        // If (a ^ b) & (a ^ c) has sign bit set => overflow.
+        if (((a ^ b) & (a ^ c)).isNeg()) {
+            throw new Error('SafeMathI128: subtraction overflow');
+        }
+
+        return c;
+    }
+
+    /*public static mul(a: i128, b: i128): i128 {
+        // Quick check: if either is ZERO, product is ZERO => no overflow
+        if (a == SafeMathI128.ZERO || b == SafeMathI128.ZERO) {
+            return SafeMathI128.ZERO;
+        }
+
+        let c = i128.mul(a, b);
+
+        // Check overflow: c / b should be exactly a (if b != 0).
+        // Also watch for the i128 edge case: MIN * -1 => possible overflow if not representable.
+        // We'll rely on the division check:
+        if (b != SafeMathI128.ZERO) {
+            let divCheck = i128.div(c, b);
+            if (divCheck != a) {
+                throw new Error('SafeMathI128: multiplication overflow');
+            }
+        }
+
+        return c;
+    }*/
+
+    /*public static div(a: i128, b: i128): i128 {
+        if (b == SafeMathI128.ZERO) {
+            throw new Error('SafeMathI128: division by zero');
+        }
+
+        // Check i128 edge case: MIN / -1 => possible overflow if no corresponding positive.
+        if (a == SafeMathI128.MIN && b == SafeMathI128.NEG_ONE) {
+            throw new Error('SafeMathI128: division overflow (MIN / -1)');
+        }
+
+        return i128.div(a, b);
+    }*/
+
+    /*public static mod(a: i128, b: i128): i128 {
+        if (b == SafeMathI128.ZERO) {
+            throw new Error('SafeMathI128: modulo by zero');
+        }
+        // Similar edge case as division:
+        if (a == SafeMathI128.MIN && b == SafeMathI128.NEG_ONE) {
+            // Some implementations might treat MIN % -1 == 0,
+            // but if the library doesn't, you may handle it similarly to division.
+            // We'll assume we throw to be safe:
+            throw new Error('SafeMathI128: modulo overflow (MIN % -1)');
+        }
+
+        // Use i128.rem, i128.mod, or the operator as appropriate.
+        return i128.rem(a, b);
+    }*/
+
+    /**
+     * Increment an i128 by 1 with overflow check.
+     */
+    public static inc(value: i128): i128 {
+        return SafeMathI128.add(value, SafeMathI128.ONE);
+    }
+
+    /**
+     * Decrement an i128 by 1 with underflow check.
+     */
+    public static dec(value: i128): i128 {
+        return SafeMathI128.sub(value, SafeMathI128.ONE);
+    }
+
+    /**
+     * Return the absolute value of x, throwing if x == MIN (since |MIN| might not be representable).
+     */
+    public static abs(x: i128): i128 {
+        if (x.isNeg()) {
+            // If x == MIN, -x can overflow.
+            if (x == SafeMathI128.MIN) {
+                throw new Error('SafeMathI128: abs overflow on MIN');
+            }
+            return x.neg();
+        }
+        return x;
+    }
+
+    /**
+     * Return the negation of x, throwing if x == MIN.
+     */
+    public static neg(x: i128): i128 {
+        if (x == SafeMathI128.MIN) {
+            throw new Error('SafeMathI128: neg overflow on MIN');
+        }
+        return x.neg();
+    }
+
+    /**
+     * Returns the smaller of two i128s.
+     */
+    public static min(a: i128, b: i128): i128 {
+        return i128.lt(a, b) ? a : b;
+    }
+
+    /**
+     * Returns the larger of two i128s.
+     */
+    public static max(a: i128, b: i128): i128 {
+        return i128.gt(a, b) ? a : b;
+    }
+}

package/runtime/utils/lengths.ts

@@ -8,7 +8,6 @@ export const U32_BYTE_LENGTH: i32 = 4;
 export const U16_BYTE_LENGTH: i32 = 2;
 export const U8_BYTE_LENGTH: i32 = 1;
 
-export const I256_BYTE_LENGTH: i32 = 32;
 export const I128_BYTE_LENGTH: i32 = 16;
 export const I64_BYTE_LENGTH: i32 = 8;
 export const I32_BYTE_LENGTH: i32 = 4;