@btc-vision/btc-runtime 1.4.5 → 1.4.6

package/runtime/storage/arrays/StoredU32Array.ts

@@ -65,7 +65,9 @@ export class StoredU32Array {
      */
     @inline
     public get(index: u64): u32 {
-        assert(index < this._length, 'Index out of bounds');
+        if (index >= this._length) {
+            return 0;
+        }
 
         const slotIndex: u64 = index / 8; // Each slot holds 8 u32s
         const subIndex: u8 = <u8>(index % 8); // 0..7
@@ -82,7 +84,10 @@ export class StoredU32Array {
      */
     @inline
     public set(index: u64, value: u32): void {
-        assert(index < this._length, 'Index exceeds current array length');
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('Set operation failed: Index exceeds maximum allowed value.');
+        }
+
         const slotIndex: u64 = index / 8;
         const subIndex: u8 = <u8>(index % 8);
 
@@ -100,7 +105,7 @@ export class StoredU32Array {
      * @param {u32} value - The u32 value to append.
      */
     public push(value: u32): void {
-        if (this._length >= this.MAX_LENGTH) {
+        if (this._length > this.MAX_LENGTH) {
             throw new Revert(
                 'Push operation failed: Array has reached its maximum allowed length.',
             );
@@ -258,7 +263,9 @@ export class StoredU32Array {
      */
     @inline
     public getAll(startIndex: u64, count: u64): u32[] {
-        assert(startIndex + count <= this._length, 'Requested range exceeds array length');
+        if ((startIndex + count) > this._length) {
+            throw new Revert('Requested range exceeds array length');
+        }
 
         if (u32.MAX_VALUE < count) {
             throw new Revert('Requested range exceeds maximum allowed value.');
@@ -344,25 +351,6 @@ export class StoredU32Array {
         return this._startIndex;
     }
 
-    /**
-     * @method setLength
-     * @description Adjusts the length of the array (may truncate if newLength < currentLength).
-     * @param {u64} newLength - The new length to set.
-     */
-    public setLength(newLength: u64): void {
-        if (newLength > this.MAX_LENGTH) {
-            throw new Revert('SetLength operation failed: Length exceeds maximum allowed value.');
-        }
-
-        if (newLength > this._startIndex) {
-            this._startIndex = newLength;
-            this._isChangedStartIndex = true;
-        }
-
-        this._length = newLength;
-        this._isChangedLength = true;
-    }
-
     /**
      * @method deleteLast
      * @description Deletes the last element of the array by setting it to zero and decrementing the length.

package/runtime/storage/arrays/StoredU8Array.ts

@@ -63,7 +63,9 @@ export class StoredU8Array {
      */
     @inline
     public get(index: u64): u8 {
-        assert(index < this._length, 'Index out of bounds');
+        if (index >= this._length) {
+            return 0;
+        }
 
         const slotIndex: u64 = index / 32; // Each slot holds thirty-two u8s
         const subIndex: u8 = <u8>(index % 32);
@@ -80,7 +82,9 @@ export class StoredU8Array {
      */
     @inline
     public set(index: u64, value: u8): void {
-        assert(index < this._length, 'Index exceeds current array length');
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('Set operation failed: Index exceeds maximum allowed value.');
+        }
 
         const slotIndex: u64 = index / 32;
         const subIndex: u8 = <u8>(index % 32);
@@ -99,7 +103,7 @@ export class StoredU8Array {
      * @param {u8} value - The u8 value to append.
      */
     public push(value: u8): void {
-        if (this._length >= this.MAX_LENGTH) {
+        if (this._length > this.MAX_LENGTH) {
             throw new Revert(
                 'Push operation failed: Array has reached its maximum allowed length.',
             );
@@ -145,38 +149,6 @@ export class StoredU8Array {
         }
     }
 
-    /**
-     * @method shift
-     * @description Removes the first element of the array by setting it to zero, decrementing the length,
-     *              and incrementing the startIndex (with wrap-around if needed).
-     */
-    public shift(): void {
-        if (this._length === 0) {
-            throw new Revert('Shift operation failed: Array is empty.');
-        }
-
-        const currentStartIndex: u64 = this._startIndex;
-        const slotIndex: u64 = currentStartIndex / 32;
-        const subIndex: u8 = <u8>(currentStartIndex % 32);
-        this.ensureValues(slotIndex);
-
-        const slotValues = this._values.get(slotIndex);
-        if (slotValues && slotValues[subIndex] !== 0) {
-            slotValues[subIndex] = 0;
-            this._isChanged.add(slotIndex);
-        }
-
-        this._length -= 1;
-        this._isChangedLength = true;
-
-        if (this._startIndex < this.MAX_LENGTH - 1) {
-            this._startIndex += 1;
-        } else {
-            this._startIndex = 0;
-        }
-        this._isChangedStartIndex = true;
-    }
-
     /**
      * @method save
      * @description Persists all cached u8 values, the length, and the startIndex to their respective storage slots if any have been modified.
@@ -251,7 +223,10 @@ export class StoredU8Array {
      */
     @inline
     public getAll(startIndex: u64, count: u64): u8[] {
-        assert(startIndex + count <= this._length, 'Requested range exceeds array length');
+        if ((startIndex + count) > this._length) {
+            throw new Revert('Requested range exceeds array length');
+        }
+
         if (u32.MAX_VALUE < count) {
             throw new Revert('Requested range exceeds maximum allowed value.');
         }
@@ -335,26 +310,6 @@ export class StoredU8Array {
         return this._startIndex;
     }
 
-    /**
-     * @method setLength
-     * @description Sets the length of the array.
-     * @param {u64} newLength - The new length to set.
-     */
-    public setLength(newLength: u64): void {
-        if (newLength > this.MAX_LENGTH) {
-            throw new Revert('SetLength operation failed: Length exceeds maximum allowed value.');
-        }
-
-        // If newLength is bigger than _startIndex, adjust startIndex
-        if (newLength > this._startIndex) {
-            this._startIndex = newLength;
-            this._isChangedStartIndex = true;
-        }
-
-        this._length = newLength;
-        this._isChangedLength = true;
-    }
-
     /**
      * @method deleteLast
      * @description Removes the last element of the array by setting it to zero and decrementing the length.

package/runtime/types/Address.ts

@@ -1,7 +1,6 @@
 import { Potential } from '../lang/Definitions';
-import { decodeHexArray, encodeHexFromBuffer } from '../utils';
+import { ADDRESS_BYTE_LENGTH, decodeHexArray, encodeHexFromBuffer } from '../utils';
 import { bech32m as _bech32m, toWords } from '../utils/b32';
-import { ADDRESS_BYTE_LENGTH } from '../utils/lengths';
 
 @final
 export class Address extends Uint8Array {

package/runtime/types/SafeMath.ts

@@ -80,15 +80,30 @@ export class SafeMath {
 
         while (!r.isZero()) {
             const quotient = SafeMath.div(old_r, r);
-            const r_copy = r;
-            r = SafeMath.sub(old_r, SafeMath.mul(quotient, r));
-            old_r = r_copy;
 
-            const s_copy = s;
-            s = SafeMath.sub(old_s, SafeMath.mul(quotient, s));
-            old_s = s_copy;
+            // --- Update r ---
+            {
+                // old_r - (quotient * r)
+                const tmp = r;
+                r = u256.sub(old_r, u256.mul(quotient, r));  // unchecked subtract
+                old_r = tmp;
+            }
+
+            // --- Update s ---
+            {
+                // old_s - (quotient * s)
+                const tmp = s;
+                s = u256.sub(old_s, u256.mul(quotient, s));  // unchecked subtract
+                old_s = tmp;
+            }
         }
 
+        // At this point, `old_r` is the gcd(k, p). If gcd != 1 => no inverse
+        // (in a prime field p, gcd=1 if k != 0).
+        // We could enforce this by checking `old_r == 1` but we'll leave it to the caller.
+
+        // The extended Euclidean algorithm says `old_s` is the inverse (possibly negative),
+        // so we reduce mod p
         return SafeMath.mod(old_s, p);
     }
 
@@ -248,52 +263,48 @@ export class SafeMath {
 
     @unsafe
     public static shl(value: u256, shift: i32): u256 {
-        if (shift == 0) {
-            return value.clone();
+        // If shift <= 0, no left shift needed (shift=0 => return clone, shift<0 => treat as 0).
+        if (shift <= 0) {
+            return shift == 0 ? value.clone() : new u256(); // or just return value if shift<0 is invalid
         }
 
-        const totalBits = 256;
-        const bitsPerSegment = 64;
+        // If shift >= 256, the result is zero
+        if (shift >= 256) {
+            return new u256();
+        }
 
-        // Normalize shift to be within 0-255 range
+        // Now shift is in [1..255]. Masking is optional for clarity:
         shift &= 255;
 
-        if (shift >= totalBits) {
-            return new u256(); // Shift size larger than width results in zero
-        }
-
-        // Determine how many full 64-bit segments we are shifting
+        const bitsPerSegment = 64;
         const segmentShift = (shift / bitsPerSegment) | 0;
         const bitShift = shift % bitsPerSegment;
 
         const segments = [value.lo1, value.lo2, value.hi1, value.hi2];
         const result = SafeMath.shlSegment(segments, segmentShift, bitShift, bitsPerSegment, 4);
-
         return new u256(result[0], result[1], result[2], result[3]);
     }
 
     public static shl128(value: u128, shift: i32): u128 {
-        if (shift == 0) {
-            return value.clone();
+        if (shift <= 0) {
+            return shift == 0 ? value.clone() : new u128();
         }
 
-        const totalBits = 256;
-        const bitsPerSegment = 64;
+        // Here the total bit width is 128, so shifting >= 128 bits => zero
+        if (shift >= 128) {
+            return new u128();
+        }
 
-        // Normalize shift to be within 0-255 range
-        shift &= 255;
+        // Mask to 0..127
+        shift &= 127;
 
-        if (shift >= totalBits) {
-            return new u128(); // Shift size larger than width results in zero
-        }
+        const bitsPerSegment = 64;
 
-        // Determine how many full 64-bit segments we are shifting
         const segmentShift = (shift / bitsPerSegment) | 0;
         const bitShift = shift % bitsPerSegment;
 
         const segments = [value.lo, value.hi];
         const result = SafeMath.shlSegment(segments, segmentShift, bitShift, bitsPerSegment, 2);
-
         return new u128(result[0], result[1]);
     }
 
@@ -369,9 +380,26 @@ export class SafeMath {
      * @returns The incremented value
      */
     static inc(value: u256): u256 {
+        if (u256.eq(value, u256.Max)) {
+            throw new Error('SafeMath: increment overflow');
+        }
+
         return value.preInc();
     }
 
+    /**
+     * Decrement a u256 value by 1
+     * @param value The value to decrement
+     * @returns The decremented value
+     */
+    public static dec(value: u256): u256 {
+        if (u256.eq(value, u256.Zero)) {
+            throw new Error('SafeMath: decrement overflow');
+        }
+
+        return value.preDec();
+    }
+
     /**
      * Approximates the binary logarithm (log2) of a u256 integer.
      * @param x - The input value for which to calculate log2(x).

package/runtime/types/SafeMathI128.ts

@@ -96,6 +96,10 @@ export class SafeMathI128 {
      * Increment an i128 by 1 with overflow check.
      */
     public static inc(value: i128): i128 {
+        if (value == SafeMathI128.MAX) {
+            throw new Error('SafeMathI128: inc overflow');
+        }
+
         return SafeMathI128.add(value, SafeMathI128.ONE);
     }
 
@@ -103,6 +107,10 @@ export class SafeMathI128 {
      * Decrement an i128 by 1 with underflow check.
      */
     public static dec(value: i128): i128 {
+        if (value == SafeMathI128.MIN) {
+            throw new Error('SafeMathI128: dec underflow');
+        }
+
         return SafeMathI128.sub(value, SafeMathI128.ONE);
     }
 

package/runtime/math/rnd.ts

@@ -1,55 +0,0 @@
-let random_state0_64: u64;
-let random_state1_64: u64;
-let random_state0_32: u32;
-let random_state1_32: u32;
-let random_seeded = false;
-
-function murmurHash3(h: u64): u64 {
-    // Force all bits of a hash block to avalanche
-    h ^= h >> 33; // see: https://github.com/aappleby/smhasher
-    // eslint-disable-next-line no-loss-of-precision
-    h *= 0xff51afd7ed558ccd;
-    h ^= h >> 33;
-    // eslint-disable-next-line no-loss-of-precision
-    h *= 0xc4ceb9fe1a85ec53;
-    h ^= h >> 33;
-    return h;
-}
-
-function splitMix32(h: u32): u32 {
-    h += 0x6d2b79f5;
-    h = (h ^ (h >> 15)) * (h | 1);
-    h ^= h + (h ^ (h >> 7)) * (h | 61);
-    return h ^ (h >> 14);
-}
-
-function seedRandom(value: i64): void {
-    // Instead zero seed use golden ratio:
-    // phi = (1 + sqrt(5)) / 2
-    // trunc(2^64 / phi) = 0x9e3779b97f4a7c15
-
-    // eslint-disable-next-line no-loss-of-precision
-    if (value == 0) value = 0x9e3779b97f4a7c15;
-    random_state0_64 = murmurHash3(value);
-    random_state1_64 = murmurHash3(~random_state0_64);
-    random_state0_32 = splitMix32(<u32>value);
-    random_state1_32 = splitMix32(random_state0_32);
-    random_seeded = true;
-}
-
-/**
- * Safe deterministic random number generator
- * @param {u64} seed - The seed to use
- */
-export function randomU64(seed: i64): u64 {
-    if (!random_seeded) seedRandom(seed);
-    let s1 = random_state0_64;
-    const s0 = random_state1_64;
-    random_state0_64 = s0;
-    s1 ^= s1 << 23;
-    s1 ^= s1 >> 17;
-    s1 ^= s0;
-    s1 ^= s0 >> 26;
-    random_state1_64 = s1;
-    return s0;
-}