Overflow Protection

pragma language_version >= 0.23;

import CompactStandardLibrary;

export ledger balance: Uint<128>;
export ledger totalSupply: Uint<128>;

// Safe addition with overflow check
export circuit safeAdd(a: Uint<128>, b: Uint<128>): Uint<128> {
    const MAX_UINT128: Uint<128> = 340282366920938463463374607431768211455 as Uint<128>;
    assert(a <= MAX_UINT128 - b, "Addition overflow");
    return (a + b) as Uint<128>;
}

// Safe subtraction with underflow check
export circuit safeSub(a: Uint<128>, b: Uint<128>): Uint<128> {
    assert(a >= b, "Subtraction underflow");
    return a - b;
}

// Safe multiplication using widening + checked cast
//
// Compact has no division operator, so we cannot pre-check
// `a <= MAX / b`. Instead we let the multiplication widen
// to a wider intermediate type and assert the result fits
// back into the target width before casting.
//
// Compact's maximum integer width is Uint<248>, so the
// product of two Uint<128> values cannot be held in a
// single Compact integer. This helper therefore checks
// Uint<64> * Uint<64>, where the Uint<128> product always
// fits.
export circuit safeMul(a: Uint<64>, b: Uint<64>): Uint<64> {
    const MAX_UINT64: Uint<64> = 18446744073709551615 as Uint<64>;
    const product: Uint<128> = (a * b) as Uint<128>;
    assert(product <= MAX_UINT64 as Uint<128>, "Multiplication overflow");
    return product as Uint<64>;
}