@btc-vision/btc-runtime 1.6.1 → 1.6.2

package/runtime/storage/arrays/StoredPackedArray.ts

@@ -8,6 +8,8 @@ import {
 import { Blockchain } from '../../env';
 import { Revert } from '../../types/Revert';
 
+export const DEFAULT_MAX_LENGTH: u32 = u32.MAX_VALUE - 1;
+
 /**
  * Abstract base class for an array of T values that are packed
  * in 32-byte (Uint8Array) "slots" in storage.
@@ -16,6 +18,8 @@ import { Revert } from '../../types/Revert';
  * - Maps each global index to (slotIndex, subIndex).
  * - Child classes define how many T items fit per 32-byte slot
  *   and how to pack/unpack them.
+ *
+ *   Note: This is designed to wrap around.
  */
 export abstract class StoredPackedArray<T> {
     /** 32-byte base pointer (used to derive storage keys). */
@@ -25,10 +29,10 @@ export abstract class StoredPackedArray<T> {
     protected readonly lengthPointer: Uint8Array;
 
     /** Internal length of the array. */
-    protected _length: u64 = 0;
+    protected _length: u32 = 0;
 
     /** Optional "start index" if needed by your logic. */
-    protected _startIndex: u64 = 0;
+    protected _startIndex: u32 = 0;
 
     /** Whether length or startIndex changed. */
     protected _isChangedLength: bool = false;
@@ -38,19 +42,23 @@ export abstract class StoredPackedArray<T> {
      * A map from slotIndex => the 32-byte slot data in memory.
      * Child classes will parse that 32 bytes into an array of T, or vice versa.
      */
-    protected _slots: Map<u64, Uint8Array> = new Map();
+    protected _slots: Map<u32, Uint8Array> = new Map();
 
     /** Track which slotIndexes are changed and need saving. */
-    protected _isChanged: Set<u64> = new Set();
+    protected _isChanged: Set<u32> = new Set();
 
-    /**
-     * Maximum length to prevent unbounded usage.
-     * Adjust to fit your constraints (e.g. `u64.MAX_VALUE`).
-     */
-    protected readonly MAX_LENGTH: u64 = <u64>(u32.MAX_VALUE - 1);
+    private nextItemOffset: u32 = 0;
 
-    protected constructor(public pointer: u16, public subPointer: Uint8Array, protected defaultValue: T) {
-        assert(subPointer.length <= 30, `You must pass a 30 bytes sub-pointer. (Array, got ${subPointer.length})`);
+    protected constructor(
+        public pointer: u16,
+        public subPointer: Uint8Array,
+        protected defaultValue: T,
+        protected MAX_LENGTH: u32 = DEFAULT_MAX_LENGTH,
+    ) {
+        assert(
+            subPointer.length <= 30,
+            `You must pass a 30 bytes sub-pointer. (Array, got ${subPointer.length})`,
+        );
 
         const basePointer = encodeBasePointer(pointer, subPointer);
         this.lengthPointer = Uint8Array.wrap(basePointer.buffer);
@@ -63,16 +71,38 @@ export abstract class StoredPackedArray<T> {
         this._startIndex = data[1];
     }
 
+    @inline
+    public get previousOffset(): u32 {
+        return <u32>(
+            ((this._startIndex +
+                <u64>(this.nextItemOffset === 0 ? this.nextItemOffset : this.nextItemOffset - 1)) %
+                <u64>this.MAX_LENGTH)
+        );
+    }
+
+    /**
+     * Set the maximum length of the array.
+     * This is a safety check to prevent unbounded usage.
+     */
+    @inline
+    public setMaxLength(maxLength: u32): void {
+        if (maxLength > this.MAX_LENGTH) {
+            throw new Revert('setMaxLength: maxLength exceeds MAX_LENGTH');
+        }
+
+        this.MAX_LENGTH = maxLength;
+    }
+
     @inline
     @operator('[]')
-    public get(index: u64): T {
+    public get(index: u32): T {
         // max length used on purpose to prevent unbounded usage
         if (index > this.MAX_LENGTH) {
             throw new Revert('get: out of range');
         }
 
-        const realIndex = (this._startIndex + index) % this.MAX_LENGTH;
-        const cap = this.getSlotCapacity();
+        const realIndex: u32 = this.getRealIndex(index);
+        const cap: u32 = this.getSlotCapacity();
         const slotIndex = realIndex / cap;
         const subIndex = <u32>(realIndex % cap);
 
@@ -83,7 +113,7 @@ export abstract class StoredPackedArray<T> {
     }
 
     @inline
-    public get_physical(index: u64): T {
+    public get_physical(index: u32): T {
         if (index > this.MAX_LENGTH) {
             throw new Revert('get: index exceeds MAX_LENGTH (packed array)');
         }
@@ -100,12 +130,12 @@ export abstract class StoredPackedArray<T> {
 
     @inline
     @operator('[]=')
-    public set(index: u64, value: T): void {
+    public set(index: u32, value: T): void {
         if (index > this.MAX_LENGTH) {
             throw new Revert('set: index exceeds MAX_LENGTH (packed array)');
         }
 
-        const realIndex = (this._startIndex + index) % this.MAX_LENGTH;
+        const realIndex: u32 = this.getRealIndex(index);
         const cap = this.getSlotCapacity();
         const slotIndex = realIndex / cap;
         const subIndex = <u32>(realIndex % cap);
@@ -122,7 +152,7 @@ export abstract class StoredPackedArray<T> {
     }
 
     @inline
-    public set_physical(index: u64, value: T): void {
+    public set_physical(index: u32, value: T): void {
         if (index > this.MAX_LENGTH) {
             throw new Revert('set: index exceeds MAX_LENGTH (packed array)');
         }
@@ -142,13 +172,48 @@ export abstract class StoredPackedArray<T> {
         }
     }
 
+    /**
+     * Get the next item in the array, starting from the current offset.
+     * This is useful for iterating through the array.
+     */
+    @inline
+    public next(): T {
+        const value = this.get(this.nextItemOffset);
+        this.nextItemOffset += 1;
+
+        return value;
+    }
+
     @inline
-    public push(value: T, isPhysical: bool = false): void {
+    public incrementStartingIndex(): void {
+        if (this._startIndex >= this.MAX_LENGTH) {
+            this._startIndex = 0;
+        } else {
+            this._startIndex += 1;
+        }
+
+        this._isChangedStartIndex = true;
+    }
+
+    /**
+     * Apply the starting index with n offset.
+     */
+    @inline
+    public applyNextOffsetToStartingIndex(): void {
+        if (!this.nextItemOffset) return;
+
+        this._startIndex += this.nextItemOffset;
+        this._isChangedStartIndex = true;
+        this.nextItemOffset = 0;
+    }
+
+    @inline
+    public push(value: T, isPhysical: bool = false): u32 {
         if (this._length >= this.MAX_LENGTH) {
             throw new Revert('push: array has reached MAX_LENGTH');
         }
 
-        const realIndex = ((isPhysical ? 0 : this._startIndex) + this._length) % this.MAX_LENGTH;
+        const realIndex: u32 = this.getRealIndex(this._length, isPhysical);
         const cap = this.getSlotCapacity();
         const slotIndex = realIndex / cap;
         const subIndex = <u32>(realIndex % cap);
@@ -165,6 +230,8 @@ export abstract class StoredPackedArray<T> {
 
         this._length += 1;
         this._isChangedLength = true;
+
+        return realIndex;
     }
 
     /**
@@ -207,8 +274,8 @@ export abstract class StoredPackedArray<T> {
      * but does not reduce the length.
      */
     @inline
-    public delete(index: u64): void {
-        const realIndex = (this._startIndex + index) % this.MAX_LENGTH;
+    public delete(index: u32): void {
+        const realIndex = this.getRealIndex(index);
         const cap = this.getSlotCapacity();
         const slotIndex = realIndex / cap;
         const subIndex = <u32>(realIndex % cap);
@@ -225,12 +292,22 @@ export abstract class StoredPackedArray<T> {
         }
     }
 
+    @inline
+    public removeItemFromLength(): void {
+        if (this._length == 0) {
+            throw new Revert('delete: array is empty');
+        }
+
+        this._length -= 1;
+        this._isChangedLength = true;
+    }
+
     /**
      * "Delete" by zeroing out the element at `index`,
      * but does not reduce the length.
      */
     @inline
-    public delete_physical(index: u64): void {
+    public delete_physical(index: u32): void {
         const cap = this.getSlotCapacity();
         const slotIndex = index / cap;
         const subIndex = <u32>(index % cap);
@@ -264,28 +341,25 @@ export abstract class StoredPackedArray<T> {
     }
 
     @inline
-    public setMultiple(startIndex: u64, values: T[]): void {
-        const end = startIndex + <u64>values.length;
+    public setMultiple(startIndex: u32, values: T[]): void {
+        const end = startIndex + <u32>values.length;
         if (end > this._length) {
             throw new Revert('setMultiple: out of range (packed array)');
         }
 
         for (let i = 0; i < values.length; i++) {
-            this.set(startIndex + <u64>i, values[i]);
+            this.set(startIndex + <u32>i, values[i]);
         }
     }
 
-    // -----------------------------------------------------------
-    //              Public Array-Like Methods
-    // -----------------------------------------------------------
     @inline
-    public getAll(startIndex: u64, count: u64): T[] {
-        if (count > <u64>u32.MAX_VALUE) {
+    public getAll(startIndex: u32, count: u32): T[] {
+        if (count > <u32>u32.MAX_VALUE) {
             throw new Revert('getAll: count too large (packed array)');
         }
 
         const out = new Array<T>(<i32>count);
-        for (let i: u64 = 0; i < count; i++) {
+        for (let i: u32 = 0; i < count; i++) {
             out[<i32>i] = this.get(startIndex + i);
         }
 
@@ -293,17 +367,17 @@ export abstract class StoredPackedArray<T> {
     }
 
     @inline
-    public getLength(): u64 {
+    public getLength(): u32 {
         return this._length;
     }
 
     @inline
-    public startingIndex(): u64 {
+    public startingIndex(): u32 {
         return this._startIndex;
     }
 
     @inline
-    public setStartingIndex(index: u64): void {
+    public setStartingIndex(index: u32): void {
         this._startIndex = index;
         this._isChangedStartIndex = true;
     }
@@ -313,7 +387,7 @@ export abstract class StoredPackedArray<T> {
      */
     public toString(): string {
         let s = '[';
-        for (let i: u64 = 0; i < this._length; i++) {
+        for (let i: u32 = 0; i < this._length; i++) {
             s += `${this.get(i)}`;
             if (i < this._length - 1) {
                 s += ', ';
@@ -329,7 +403,7 @@ export abstract class StoredPackedArray<T> {
             const slotIndex = changed[i];
             const slotData = this._slots.get(slotIndex);
             if (slotData) {
-                const ptr = this.calculateStoragePointer(slotIndex);
+                const ptr = this.calculateStoragePointer(<u64>slotIndex);
                 Blockchain.setStorageAt(ptr, slotData);
             }
         }
@@ -348,7 +422,7 @@ export abstract class StoredPackedArray<T> {
         const keys = this._slots.keys();
         for (let i = 0; i < keys.length; i++) {
             const slotIndex = keys[i];
-            const ptr = this.calculateStoragePointer(slotIndex);
+            const ptr = this.calculateStoragePointer(<u64>slotIndex);
             Blockchain.setStorageAt(ptr, GET_EMPTY_BUFFER()); // 32 bytes of zero
         }
 
@@ -379,7 +453,7 @@ export abstract class StoredPackedArray<T> {
     }
 
     /** Number of T items that fit in one 32-byte slot. */
-    protected abstract getSlotCapacity(): u64;
+    protected abstract getSlotCapacity(): u32;
 
     /** Return the "zero" value of type T. */
     protected abstract zeroValue(): T;
@@ -387,10 +461,6 @@ export abstract class StoredPackedArray<T> {
     /** Compare two T values for equality. */
     protected abstract eq(a: T, b: T): bool;
 
-    // -----------------------------------------------------------
-    //                 Persistence (save, reset, etc.)
-    // -----------------------------------------------------------
-
     /**
      * Pack an array of T (length = getSlotCapacity()) into a 32-byte buffer.
      */
@@ -408,16 +478,12 @@ export abstract class StoredPackedArray<T> {
      */
     protected abstract calculateStoragePointer(slotIndex: u64): Uint8Array;
 
-    // -----------------------------------------------------------
-    //              Internal Slot-Loading Helpers
-    // -----------------------------------------------------------
-
     /**
      * Ensure that slotIndex is loaded into _slots. If missing, read from storage.
      */
-    protected ensureSlot(slotIndex: u64): Uint8Array {
+    protected ensureSlot(slotIndex: u32): Uint8Array {
         if (!this._slots.has(slotIndex)) {
-            const ptr = this.calculateStoragePointer(slotIndex);
+            const ptr = this.calculateStoragePointer(<u64>slotIndex);
             const data = Blockchain.getStorageAt(ptr);
 
             // Must be exactly 32 bytes; if it's empty, you get 32 zero bytes from GET_EMPTY_BUFFER()
@@ -426,4 +492,14 @@ export abstract class StoredPackedArray<T> {
 
         return this._slots.get(slotIndex);
     }
+
+    private getRealIndex(index: u32, isPhysical: bool = false): u32 {
+        const maxLength: u64 = <u64>this.MAX_LENGTH;
+        let realIndex: u64 = (isPhysical ? <u64>0 : <u64>this._startIndex) + <u64>index;
+        if (!(realIndex < maxLength)) {
+            realIndex %= maxLength;
+        }
+
+        return <u32>realIndex;
+    }
 }

package/runtime/storage/arrays/StoredU128Array.ts

@@ -1,4 +1,4 @@
-import { StoredPackedArray } from './StoredPackedArray';
+import { DEFAULT_MAX_LENGTH, StoredPackedArray } from './StoredPackedArray';
 import { u128 } from '@btc-vision/as-bignum/assembly';
 import { bigEndianAdd } from '../../math/bytes';
 
@@ -9,16 +9,16 @@ import { bigEndianAdd } from '../../math/bytes';
  */
 @final
 export class StoredU128Array extends StoredPackedArray<u128> {
-    public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer, u128.Zero);
+    public constructor(pointer: u16, subPointer: Uint8Array, maxLength: u32 = DEFAULT_MAX_LENGTH) {
+        super(pointer, subPointer, u128.Zero, maxLength);
     }
 
-    protected getSlotCapacity(): u64 {
+    protected getSlotCapacity(): u32 {
         return 2; // 2 x u128 => 32 bytes
     }
 
     protected zeroValue(): u128 {
-        return u128.Zero;  // from the as-bignum library
+        return u128.Zero; // from the as-bignum library
     }
 
     protected eq(a: u128, b: u128): bool {
@@ -61,4 +61,4 @@ export class StoredU128Array extends StoredPackedArray<u128> {
     protected calculateStoragePointer(slotIndex: u64): Uint8Array {
         return bigEndianAdd(this.basePointer, slotIndex);
     }
-}
+}

package/runtime/storage/arrays/StoredU16Array.ts

@@ -1,4 +1,4 @@
-import { StoredPackedArray } from './StoredPackedArray';
+import { DEFAULT_MAX_LENGTH, StoredPackedArray } from './StoredPackedArray';
 import { bigEndianAdd } from '../../math/bytes';
 
 /**
@@ -6,11 +6,11 @@ import { bigEndianAdd } from '../../math/bytes';
  */
 @final
 export class StoredU16Array extends StoredPackedArray<u16> {
-    public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer, 0);
+    public constructor(pointer: u16, subPointer: Uint8Array, maxLength: u32 = DEFAULT_MAX_LENGTH) {
+        super(pointer, subPointer, 0, maxLength);
     }
 
-    protected getSlotCapacity(): u64 {
+    protected getSlotCapacity(): u32 {
         return 16; // 16 x u16 = 32 bytes
     }
 
@@ -30,8 +30,8 @@ export class StoredU16Array extends StoredPackedArray<u16> {
         let offset = 0;
         for (let i = 0; i < 16; i++) {
             const v = values[i];
-            out[offset] = <u8>((v >> 8) & 0xff);   // high byte
-            out[offset + 1] = <u8>(v & 0xff);         // low byte
+            out[offset] = <u8>((v >> 8) & 0xff); // high byte
+            out[offset + 1] = <u8>(v & 0xff); // low byte
             offset += 2;
         }
         return out;

package/runtime/storage/arrays/StoredU256Array.ts

@@ -1,4 +1,4 @@
-import { StoredPackedArray } from './StoredPackedArray';
+import { DEFAULT_MAX_LENGTH, StoredPackedArray } from './StoredPackedArray';
 import { u256 } from '@btc-vision/as-bignum/assembly';
 import { bigEndianAdd } from '../../math/bytes';
 
@@ -8,11 +8,11 @@ import { bigEndianAdd } from '../../math/bytes';
  */
 @final
 export class StoredU256Array extends StoredPackedArray<u256> {
-    public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer, u256.Zero);
+    public constructor(pointer: u16, subPointer: Uint8Array, maxLength: u32 = DEFAULT_MAX_LENGTH) {
+        super(pointer, subPointer, u256.Zero, maxLength);
     }
 
-    protected getSlotCapacity(): u64 {
+    protected getSlotCapacity(): u32 {
         return 1; // 1 x u256 => 32 bytes
     }
 
@@ -36,4 +36,4 @@ export class StoredU256Array extends StoredPackedArray<u256> {
     protected calculateStoragePointer(slotIndex: u64): Uint8Array {
         return bigEndianAdd(this.basePointer, slotIndex);
     }
-}
+}

package/runtime/storage/arrays/StoredU32Array.ts

@@ -1,4 +1,4 @@
-import { StoredPackedArray } from './StoredPackedArray';
+import { DEFAULT_MAX_LENGTH, StoredPackedArray } from './StoredPackedArray';
 import { bigEndianAdd } from '../../math/bytes';
 
 /**
@@ -7,11 +7,11 @@ import { bigEndianAdd } from '../../math/bytes';
  */
 @final
 export class StoredU32Array extends StoredPackedArray<u32> {
-    public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer, 0);
+    public constructor(pointer: u16, subPointer: Uint8Array, maxLength: u32 = DEFAULT_MAX_LENGTH) {
+        super(pointer, subPointer, 0, maxLength);
     }
 
-    protected getSlotCapacity(): u64 {
+    protected getSlotCapacity(): u32 {
         return 8; // 8 x u32 => 32 bytes
     }
 
@@ -45,7 +45,7 @@ export class StoredU32Array extends StoredPackedArray<u32> {
             const b1 = slotData[offset + 1];
             const b2 = slotData[offset + 2];
             const b3 = slotData[offset + 3];
-            out[i] = ((<u32>b0 << 24) | (<u32>b1 << 16) | (<u32>b2 << 8) | b3) as u32;
+            out[i] = (((<u32>b0) << 24) | ((<u32>b1) << 16) | ((<u32>b2) << 8) | b3) as u32;
             offset += 4;
         }
         return out;

package/runtime/storage/arrays/StoredU64Array.ts

@@ -1,4 +1,4 @@
-import { StoredPackedArray } from './StoredPackedArray';
+import { DEFAULT_MAX_LENGTH, StoredPackedArray } from './StoredPackedArray';
 import { bigEndianAdd } from '../../math/bytes';
 
 /**
@@ -7,11 +7,11 @@ import { bigEndianAdd } from '../../math/bytes';
  */
 @final
 export class StoredU64Array extends StoredPackedArray<u64> {
-    public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer, 0);
+    public constructor(pointer: u16, subPointer: Uint8Array, maxLength: u32 = DEFAULT_MAX_LENGTH) {
+        super(pointer, subPointer, 0, maxLength);
     }
 
-    protected getSlotCapacity(): u64 {
+    protected getSlotCapacity(): u32 {
         return 4; // 4 x u64 => 32 bytes
     }
 
@@ -53,8 +53,15 @@ export class StoredU64Array extends StoredPackedArray<u64> {
             const b5 = <u64>slotData[offset + 5];
             const b6 = <u64>slotData[offset + 6];
             const b7 = <u64>slotData[offset + 7];
-            out[i] = (b0 << 56) | (b1 << 48) | (b2 << 40) | (b3 << 32) |
-                (b4 << 24) | (b5 << 16) | (b6 << 8) | b7;
+            out[i] =
+                (b0 << 56) |
+                (b1 << 48) |
+                (b2 << 40) |
+                (b3 << 32) |
+                (b4 << 24) |
+                (b5 << 16) |
+                (b6 << 8) |
+                b7;
             offset += 8;
         }
         return out;
@@ -63,4 +70,4 @@ export class StoredU64Array extends StoredPackedArray<u64> {
     protected calculateStoragePointer(slotIndex: u64): Uint8Array {
         return bigEndianAdd(this.basePointer, slotIndex);
     }
-}
+}

package/runtime/storage/arrays/StoredU8Array.ts

@@ -1,4 +1,4 @@
-import { StoredPackedArray } from './StoredPackedArray';
+import { DEFAULT_MAX_LENGTH, StoredPackedArray } from './StoredPackedArray';
 import { bigEndianAdd } from '../../math/bytes';
 
 /**
@@ -7,11 +7,11 @@ import { bigEndianAdd } from '../../math/bytes';
  */
 @final
 export class StoredU8Array extends StoredPackedArray<u8> {
-    public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer, 0);
+    public constructor(pointer: u16, subPointer: Uint8Array, maxLength: u32 = DEFAULT_MAX_LENGTH) {
+        super(pointer, subPointer, 0, maxLength);
     }
 
-    protected getSlotCapacity(): u64 {
+    protected getSlotCapacity(): u32 {
         return 32; // 32 bytes => 32 x u8
     }
 
@@ -45,4 +45,4 @@ export class StoredU8Array extends StoredPackedArray<u8> {
         // basePointer + (slotIndex+1) in big-endian
         return bigEndianAdd(this.basePointer, slotIndex);
     }
-}
+}

package/runtime/storage/maps/StoredMapU256.ts

@@ -0,0 +1,62 @@
+import {u256} from '@btc-vision/as-bignum/assembly';
+import {Blockchain} from '../../env';
+import {EMPTY_BUFFER} from "../../math/bytes";
+import {BytesWriter} from "../../buffer/BytesWriter";
+import {encodePointerUnknownLength} from "../../math/abi";
+
+/**
+ * StoredMap<K, V> implementation using u256 as keys.
+ */
+@final
+export class StoredMapU256 {
+    private readonly pointer: u16;
+    private readonly subPointer: Uint8Array;
+
+    constructor(pointer: u16, subPointer: Uint8Array = new Uint8Array(30)) {
+        this.pointer = pointer;
+        this.subPointer = subPointer;
+    }
+
+    /**
+     * Sets the value for a given key.
+     * @param key - The key of type K.
+     * @param value - The value of type V.
+     */
+    public set(key: u256, value: u256): void {
+        const keyPointer = this.getKeyPointer(key);
+        Blockchain.setStorageAt(keyPointer, value.toUint8Array(true));
+    }
+
+    /**
+     * Retrieves the value for a given key.
+     * @param key - The key of type K.
+     * @returns The value of type V or null if the key does not exist.
+     */
+    public get(key: u256): u256 {
+        const keyPointer = this.getKeyPointer(key);
+        return u256.fromUint8ArrayBE(Blockchain.getStorageAt(keyPointer));
+    }
+
+    /**
+     * Deletes the value for a given key.
+     * @param key - The key of type K.
+     */
+    public delete(key: u256): void {
+        const keyPointer = this.getKeyPointer(key);
+        Blockchain.setStorageAt(keyPointer, EMPTY_BUFFER);
+    }
+
+    /**
+     * Generates the storage pointer for a given key.
+     * @param key - The key of type K.
+     * @returns The storage pointer as u256.
+     */
+    private getKeyPointer(key: u256): Uint8Array {
+        const writer = new BytesWriter(64);
+
+        writer.writeBytes(this.subPointer);
+        writer.writeU256(key);
+
+        return encodePointerUnknownLength(this.pointer, writer.getBuffer());
+    }
+}

package/runtime/types/SafeMath.ts

@@ -154,6 +154,40 @@ export class SafeMath {
         return c;
     }
 
+    public static mul64(a: u64, b: u64): u64 {
+        if (a === 0 || b === 0) {
+            return 0;
+        }
+
+        const c: u64 = a * b;
+
+        if (c / a !== b) {
+            throw new Error('SafeMath: multiplication overflow');
+        }
+
+        return c;
+    }
+
+    public static div64(a: u64, b: u64): u64 {
+        if (b === 0) {
+            throw new Error('Division by zero');
+        }
+
+        if (a === 0) {
+            return 0;
+        }
+
+        if (a < b) {
+            return 0; // Return 0 if a < b
+        }
+
+        if (a === b) {
+            return 1; // Return 1 if a == b
+        }
+
+        return a / b;
+    }
+
     public static div128(a: u128, b: u128): u128 {
         if (b.isZero()) {
             throw new Error('Division by zero');
@@ -226,6 +260,22 @@ export class SafeMath {
         return result;
     }
 
+    public static min64(a: u64, b: u64): u64 {
+        return a < b ? a : b;
+    }
+
+    public static max64(a: u64, b: u64): u64 {
+        return a > b ? a : b;
+    }
+
+    public static min128(a: u128, b: u128): u128 {
+        return u128.lt(a, b) ? a : b;
+    }
+
+    public static max128(a: u128, b: u128): u128 {
+        return u128.gt(a, b) ? a : b;
+    }
+
     public static min(a: u256, b: u256): u256 {
         return u256.lt(a, b) ? a : b;
     }