@btc-vision/btc-runtime 1.0.30 → 1.0.31

package/runtime/types/SafeMath.ts

@@ -1,197 +1,197 @@
-import { u256 } from 'as-bignum/assembly';
-
-export class SafeMath {
-    public static ZERO: u256 = u256.fromU32(0);
-
-    public static add(a: u256, b: u256): u256 {
-        const c: u256 = u256.add(a, b);
-        if (c < a) {
-            throw new Error('SafeMath: addition overflow');
-        }
-        return c;
-    }
-
-    public static sub(a: u256, b: u256): u256 {
-        if (a < b) {
-            throw new Error('SafeMath: subtraction overflow');
-        }
-
-        return u256.sub(a, b);
-    }
-
-    // Computes (a * b) % modulus with full precision
-    public static mulmod(a: u256, b: u256, modulus: u256): u256 {
-        if (u256.eq(modulus, u256.Zero)) throw new Error('SafeMath: modulo by zero');
-
-        const mul = SafeMath.mul(a, b);
-        return SafeMath.mod(mul, modulus);
-    }
-
-    @inline
-    @unsafe
-    @operator('%')
-    public static mod(a: u256, b: u256): u256 {
-        if (u256.eq(b, u256.Zero)) {
-            throw new Error('SafeMath: modulo by zero');
-        }
-
-        let result = a.clone();
-        while (u256.ge(result, b)) {
-            result = u256.sub(result, b);
-        }
-
-        return result;
-    }
-
-    public static mul(a: u256, b: u256): u256 {
-        if (a === SafeMath.ZERO || b === SafeMath.ZERO) {
-            return SafeMath.ZERO;
-        }
-
-        const c: u256 = u256.mul(a, b);
-        const d: u256 = SafeMath.div(c, a);
-
-        if (u256.ne(d, b)) {
-            throw new Error('SafeMath: multiplication overflow');
-        }
-
-        return c;
-    }
-
-    @inline
-    @unsafe
-    @operator('/')
-    public static div(a: u256, b: u256): u256 {
-        if (b.isZero()) {
-            throw new Error('Division by zero');
-        }
-
-        if (a.isZero()) {
-            return new u256();
-        }
-
-        if (u256.lt(a, b)) {
-            return new u256(); // Return 0 if a < b
-        }
-
-        if (u256.eq(a, b)) {
-            return new u256(1); // Return 1 if a == b
-        }
-
-        let n = a.clone();
-        let d = b.clone();
-        let result = new u256();
-
-        let shift = u256.clz(d) - u256.clz(n);
-        d = SafeMath.shl(d, shift); // align d with n by shifting left
-
-        for (let i = shift; i >= 0; i--) {
-            if (u256.ge(n, d)) {
-                n = u256.sub(n, d);
-                result = u256.or(result, SafeMath.shl(u256.One, i));
-            }
-            d = u256.shr(d, 1); // restore d to original by shifting right
-        }
-
-        return result;
-    }
-
-    public static min(a: u256, b: u256): u256 {
-        return u256.lt(a, b) ? a : b;
-    }
-
-    public static max(a: u256, b: u256): u256 {
-        return u256.gt(a, b) ? a : b;
-    }
-
-    @inline
-    @unsafe
-    public static sqrt(y: u256): u256 {
-        if (u256.gt(y, u256.fromU32(3))) {
-            let z = y;
-
-            let u246_2 = u256.fromU32(2);
-
-            let d = SafeMath.div(y, u246_2);
-            let x = SafeMath.add(d, u256.One);
-
-            while (u256.lt(x, z)) {
-                z = x;
-
-                let u = SafeMath.div(y, x);
-                let y2 = u256.add(u, x);
-
-                x = SafeMath.div(y2, u246_2);
-            }
-
-            return z;
-        } else if (!u256.eq(y, u256.Zero)) {
-            return u256.One;
-        } else {
-            return u256.Zero;
-        }
-    }
-
-    @inline
-    @unsafe
-    public static shl(value: u256, shift: i32): u256 {
-        if (shift == 0) {
-            return value.clone();
-        }
-
-        let totalBits = 256;
-        let bitsPerSegment = 64;
-
-        // Normalize shift to be within 0-255 range
-        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
-        let segmentShift = (shift / bitsPerSegment) | 0;
-        let bitShift = shift % bitsPerSegment;
-
-        let segments = [value.lo1, value.lo2, value.hi1, value.hi2];
-
-        let result = new Array<u64>(4).fill(0);
-
-        for (let i = 0; i < segments.length; i++) {
-            if (i + segmentShift < segments.length) {
-                result[i + segmentShift] |= segments[i] << bitShift;
-            }
-            if (bitShift != 0 && i + segmentShift + 1 < segments.length) {
-                result[i + segmentShift + 1] |= segments[i] >>> (bitsPerSegment - bitShift);
-            }
-        }
-
-        return new u256(result[0], result[1], result[2], result[3]);
-    }
-
-    public static and(a: u256, b: u256): u256 {
-        return u256.and(a, b);
-    }
-
-    public static or(a: u256, b: u256): u256 {
-        return u256.or(a, b);
-    }
-
-    public static xor(a: u256, b: u256): u256 {
-        return u256.xor(a, b);
-    }
-
-    public static shr(a: u256, b: u32): u256 {
-        return u256.shr(a, b);
-    }
-
-    /**
-     * Increment a u256 value by 1
-     * @param value The value to increment
-     * @returns The incremented value
-     */
-    @inline
-    static inc(value: u256): u256 {
-        return value.preInc();
-    }
-}
+import { u256 } from 'as-bignum/assembly';
+
+export class SafeMath {
+    public static ZERO: u256 = u256.fromU32(0);
+
+    public static add(a: u256, b: u256): u256 {
+        const c: u256 = u256.add(a, b);
+        if (c < a) {
+            throw new Error('SafeMath: addition overflow');
+        }
+        return c;
+    }
+
+    public static sub(a: u256, b: u256): u256 {
+        if (a < b) {
+            throw new Error('SafeMath: subtraction overflow');
+        }
+
+        return u256.sub(a, b);
+    }
+
+    // Computes (a * b) % modulus with full precision
+    public static mulmod(a: u256, b: u256, modulus: u256): u256 {
+        if (u256.eq(modulus, u256.Zero)) throw new Error('SafeMath: modulo by zero');
+
+        const mul = SafeMath.mul(a, b);
+        return SafeMath.mod(mul, modulus);
+    }
+
+    @inline
+    @unsafe
+    @operator('%')
+    public static mod(a: u256, b: u256): u256 {
+        if (u256.eq(b, u256.Zero)) {
+            throw new Error('SafeMath: modulo by zero');
+        }
+
+        let result = a.clone();
+        while (u256.ge(result, b)) {
+            result = u256.sub(result, b);
+        }
+
+        return result;
+    }
+
+    public static mul(a: u256, b: u256): u256 {
+        if (a === SafeMath.ZERO || b === SafeMath.ZERO) {
+            return SafeMath.ZERO;
+        }
+
+        const c: u256 = u256.mul(a, b);
+        const d: u256 = SafeMath.div(c, a);
+
+        if (u256.ne(d, b)) {
+            throw new Error('SafeMath: multiplication overflow');
+        }
+
+        return c;
+    }
+
+    @inline
+    @unsafe
+    @operator('/')
+    public static div(a: u256, b: u256): u256 {
+        if (b.isZero()) {
+            throw new Error('Division by zero');
+        }
+
+        if (a.isZero()) {
+            return new u256();
+        }
+
+        if (u256.lt(a, b)) {
+            return new u256(); // Return 0 if a < b
+        }
+
+        if (u256.eq(a, b)) {
+            return new u256(1); // Return 1 if a == b
+        }
+
+        let n = a.clone();
+        let d = b.clone();
+        let result = new u256();
+
+        let shift = u256.clz(d) - u256.clz(n);
+        d = SafeMath.shl(d, shift); // align d with n by shifting left
+
+        for (let i = shift; i >= 0; i--) {
+            if (u256.ge(n, d)) {
+                n = u256.sub(n, d);
+                result = u256.or(result, SafeMath.shl(u256.One, i));
+            }
+            d = u256.shr(d, 1); // restore d to original by shifting right
+        }
+
+        return result;
+    }
+
+    public static min(a: u256, b: u256): u256 {
+        return u256.lt(a, b) ? a : b;
+    }
+
+    public static max(a: u256, b: u256): u256 {
+        return u256.gt(a, b) ? a : b;
+    }
+
+    @inline
+    @unsafe
+    public static sqrt(y: u256): u256 {
+        if (u256.gt(y, u256.fromU32(3))) {
+            let z = y;
+
+            let u246_2 = u256.fromU32(2);
+
+            let d = SafeMath.div(y, u246_2);
+            let x = SafeMath.add(d, u256.One);
+
+            while (u256.lt(x, z)) {
+                z = x;
+
+                let u = SafeMath.div(y, x);
+                let y2 = u256.add(u, x);
+
+                x = SafeMath.div(y2, u246_2);
+            }
+
+            return z;
+        } else if (!u256.eq(y, u256.Zero)) {
+            return u256.One;
+        } else {
+            return u256.Zero;
+        }
+    }
+
+    @inline
+    @unsafe
+    public static shl(value: u256, shift: i32): u256 {
+        if (shift == 0) {
+            return value.clone();
+        }
+
+        let totalBits = 256;
+        let bitsPerSegment = 64;
+
+        // Normalize shift to be within 0-255 range
+        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
+        let segmentShift = (shift / bitsPerSegment) | 0;
+        let bitShift = shift % bitsPerSegment;
+
+        let segments = [value.lo1, value.lo2, value.hi1, value.hi2];
+
+        let result = new Array<u64>(4).fill(0);
+
+        for (let i = 0; i < segments.length; i++) {
+            if (i + segmentShift < segments.length) {
+                result[i + segmentShift] |= segments[i] << bitShift;
+            }
+            if (bitShift != 0 && i + segmentShift + 1 < segments.length) {
+                result[i + segmentShift + 1] |= segments[i] >>> (bitsPerSegment - bitShift);
+            }
+        }
+
+        return new u256(result[0], result[1], result[2], result[3]);
+    }
+
+    public static and(a: u256, b: u256): u256 {
+        return u256.and(a, b);
+    }
+
+    public static or(a: u256, b: u256): u256 {
+        return u256.or(a, b);
+    }
+
+    public static xor(a: u256, b: u256): u256 {
+        return u256.xor(a, b);
+    }
+
+    public static shr(a: u256, b: u32): u256 {
+        return u256.shr(a, b);
+    }
+
+    /**
+     * Increment a u256 value by 1
+     * @param value The value to increment
+     * @returns The incremented value
+     */
+    @inline
+    static inc(value: u256): u256 {
+        return value.preInc();
+    }
+}

package/runtime/types/index.ts

@@ -1,8 +1,8 @@
-import { Map } from '../generic/Map';
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
-import { MemorySlotData } from '../memory/MemorySlot';
-import { u256 } from 'as-bignum/assembly';
-import { Address } from './Address';
-
-export type PointerStorage = Map<MemorySlotPointer, MemorySlotData<u256>>;
-export type BlockchainStorage = Map<Address, PointerStorage>;
+import { Map } from '../generic/Map';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { MemorySlotData } from '../memory/MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+import { Address } from './Address';
+
+export type PointerStorage = Map<MemorySlotPointer, MemorySlotData<u256>>;
+export type BlockchainStorage = Map<Address, PointerStorage>;

package/runtime/universal/ABIRegistry.ts

@@ -1,72 +1,72 @@
-import { encodeSelector, Selector } from '../math/abi';
-import { BytesReader } from '../buffer/BytesReader';
-import { BytesWriter } from '../buffer/BytesWriter';
-import { Map } from '../generic/Map';
-
-export type Calldata = NonNullable<BytesReader>;
-export type SelectorsMap = Map<u32, Uint8Array>;
-
-class ABIRegistryBase {
-    private methodMap: Selector[] = [];
-    private selectors: SelectorsMap = new Map();
-
-    private viewSelectors: Selector[] = [];
-    private allowedWriteMethods: Selector[] = [];
-
-    // Register properties with their selectors and handlers
-    public defineGetterSelector(name: string, canWrite: boolean): void {
-        const selector: Selector = encodeSelector(name);
-
-        const selectorWriter: BytesWriter = new BytesWriter();
-        selectorWriter.writeABISelector(name, selector);
-
-        if (!this.selectors.has(selector)) {
-            this.selectors.set(selector, selectorWriter.getBuffer());
-        }
-
-        if (canWrite) this.addToWriteMethods(selector);
-
-        if (!this.viewSelectors.includes(selector)) {
-            this.viewSelectors.push(selector);
-        }
-    }
-
-    public getViewSelectors(): Uint8Array {
-        const writer: BytesWriter = new BytesWriter();
-        writer.writeViewSelectorMap(this.selectors);
-
-        return writer.getBuffer();
-    }
-
-    public getMethodSelectors(): Uint8Array {
-        const writer: BytesWriter = new BytesWriter();
-        writer.writeMethodSelectorsMap(this.methodMap);
-
-        return writer.getBuffer();
-    }
-
-    public getWriteMethods(): Uint8Array {
-        const writer: BytesWriter = new BytesWriter();
-        writer.writeMethodSelectorsMap(this.allowedWriteMethods);
-
-        return writer.getBuffer();
-    }
-
-    // Register methods with their selectors and handlers
-    public defineMethodSelector(name: string, canWrite: boolean): void {
-        const selector: u32 = encodeSelector(name);
-        if (canWrite) this.addToWriteMethods(selector);
-
-        if (!this.methodMap.includes(selector)) {
-            this.methodMap.push(selector);
-        }
-    }
-
-    private addToWriteMethods(selector: Selector): void {
-        if (!this.allowedWriteMethods.includes(selector)) {
-            this.allowedWriteMethods.push(selector);
-        }
-    }
-}
-
-export const ABIRegistry = new ABIRegistryBase();
+import { encodeSelector, Selector } from '../math/abi';
+import { BytesReader } from '../buffer/BytesReader';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { Map } from '../generic/Map';
+
+export type Calldata = NonNullable<BytesReader>;
+export type SelectorsMap = Map<u32, Uint8Array>;
+
+class ABIRegistryBase {
+    private methodMap: Selector[] = [];
+    private selectors: SelectorsMap = new Map();
+
+    private viewSelectors: Selector[] = [];
+    private allowedWriteMethods: Selector[] = [];
+
+    // Register properties with their selectors and handlers
+    public defineGetterSelector(name: string, canWrite: boolean): void {
+        const selector: Selector = encodeSelector(name);
+
+        const selectorWriter: BytesWriter = new BytesWriter();
+        selectorWriter.writeABISelector(name, selector);
+
+        if (!this.selectors.has(selector)) {
+            this.selectors.set(selector, selectorWriter.getBuffer());
+        }
+
+        if (canWrite) this.addToWriteMethods(selector);
+
+        if (!this.viewSelectors.includes(selector)) {
+            this.viewSelectors.push(selector);
+        }
+    }
+
+    public getViewSelectors(): Uint8Array {
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeViewSelectorMap(this.selectors);
+
+        return writer.getBuffer();
+    }
+
+    public getMethodSelectors(): Uint8Array {
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeMethodSelectorsMap(this.methodMap);
+
+        return writer.getBuffer();
+    }
+
+    public getWriteMethods(): Uint8Array {
+        const writer: BytesWriter = new BytesWriter();
+        writer.writeMethodSelectorsMap(this.allowedWriteMethods);
+
+        return writer.getBuffer();
+    }
+
+    // Register methods with their selectors and handlers
+    public defineMethodSelector(name: string, canWrite: boolean): void {
+        const selector: u32 = encodeSelector(name);
+        if (canWrite) this.addToWriteMethods(selector);
+
+        if (!this.methodMap.includes(selector)) {
+            this.methodMap.push(selector);
+        }
+    }
+
+    private addToWriteMethods(selector: Selector): void {
+        if (!this.allowedWriteMethods.includes(selector)) {
+            this.allowedWriteMethods.push(selector);
+        }
+    }
+}
+
+export const ABIRegistry = new ABIRegistryBase();