bun add tevm

import * as Uint128 from 'tevm/Uint128';

// Create from various sources
const a = Uint128(100n);
const b = Uint128("0xff");
const c = Uint128(255);

// Arithmetic with wrapping
const sum = Uint128.plus(a, b);
const product = Uint128.times(a, c);

// Comparisons
if (Uint128.greaterThan(sum, product)) {
  console.log("Sum is larger");
}

// Conversions
const hex = Uint128.toHex(sum);
const bytes = Uint128.toBytes(sum);
console.log(`Result: ${Uint128.toString(sum)}`);

Uint128.SIZE;  // 16
Uint128.MAX;   // 340282366920938463463374607431768211455n
Uint128.MIN;   // 0n
Uint128.ZERO;  // 0n
Uint128.ONE;   // 1n

const a = Uint128(100n);
const b = Uint128(255);
const c = Uint128("0xff");
const d = Uint128("1000000000000000000");

const value = Uint128.fromBigInt(12345678901234567890n);

const value = Uint128(255);

const a = Uint128("0xff");
const b = Uint128("ffffffffffffffffffffffffffffffff");

const bytes = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255]);
const value = Uint128(bytes);

const abiBytes = Bytes32();
abiBytes[31] = 255;
const value = Uint128(abiBytes);

const valid = Uint128.tryFrom(100n);    // 100n
const invalid = Uint128.tryFrom(-1);    // null

const bigint = Uint128.toBigInt(value);

const num = Uint128.toNumber(value);

const hex = Uint128.toHex(value);  // "0xff"

const bytes = Uint128.toBytes(value);  // Uint8Array[16]

const encoded = Uint128.toAbiEncoded(value);  // Uint8Array[32]

const str = Uint128.toString(value);  // "255"

const sum = Uint128.plus(a, b);

// Wrapping behavior
const max = Uint128.MAX;
const wrapped = Uint128.plus(max, Uint128(1n));  // 0n

const diff = Uint128.minus(a, b);

// Wrapping on underflow
const zero = Uint128(0n);
const wrapped = Uint128.minus(zero, Uint128(1n));  // MAX

const product = Uint128.times(a, b);

const quotient = Uint128.dividedBy(a, b);

const remainder = Uint128.modulo(a, b);

const result = Uint128.toPower(base, exponent);

// Example
const base = Uint128(2n);
const exp = Uint128(10n);
const power = Uint128.toPower(base, exp);  // 1024n

const isEqual = Uint128.equals(a, b);
const notEqual = Uint128.notEquals(a, b);

const isLess = Uint128.lessThan(a, b);
const isLessOrEqual = Uint128.lessThanOrEqual(a, b);

const isGreater = Uint128.greaterThan(a, b);
const isGreaterOrEqual = Uint128.greaterThanOrEqual(a, b);

const min = Uint128.minimum(a, b);
const max = Uint128.maximum(a, b);

const values = [Uint128(100n), Uint128(50n), Uint128(75n)];
const minValue = Uint128.min(values);  // 50n
const maxValue = Uint128.max(values);  // 100n

const andResult = Uint128.bitwiseAnd(a, b);
const orResult = Uint128.bitwiseOr(a, b);
const xorResult = Uint128.bitwiseXor(a, b);

const inverted = Uint128.bitwiseNot(a);

const shifted = Uint128.shiftLeft(value, 8);   // value << 8
const shifted = Uint128.shiftRight(value, 8);  // value >> 8

const isZero = Uint128.isZero(value);

const valid = Uint128.isValid(100n);   // true
const invalid = Uint128.isValid(-1);   // false

const bits = Uint128.bitLength(value);  // 0-128

const zeros = Uint128.leadingZeros(value);  // 0-128

const count = Uint128.popCount(value);

const copy = Uint128.clone(value);

const values = [Uint128(100n), Uint128(50n), Uint128(75n)];
const total = Uint128.sum(values);  // 225n

const values = [Uint128(10n), Uint128(5n), Uint128(2n)];
const result = Uint128.product(values);  // 100n

const a = Uint128(48n);
const b = Uint128(18n);
const divisor = Uint128.gcd(a, b);  // 6n

const a = Uint128(12n);
const b = Uint128(18n);
const multiple = Uint128.lcm(a, b);  // 36n

const isPower = Uint128.isPowerOf2(Uint128(16n));   // true
const notPower = Uint128.isPowerOf2(Uint128(15n));  // false

// Track cumulative gas used across blocks
let cumulativeGas = Uint128(0n);

for (const block of blocks) {
  const blockGas = Uint128(block.gasUsed);
  cumulativeGas = Uint128.plus(cumulativeGas, blockGas);
}

console.log(`Total gas: ${Uint128.toString(cumulativeGas)}`);

// Calculate total supply with 18 decimals
const tokenAmounts = [
  Uint128(1000000000000000000n),  // 1 token
  Uint128(2500000000000000000n),  // 2.5 tokens
  Uint128(500000000000000000n),   // 0.5 tokens
];

const totalSupply = Uint128.sum(tokenAmounts);
console.log(`Total: ${Uint128.toString(totalSupply)} wei`);

// Calculate compound interest: principal * (1 + rate)^periods
const principal = Uint128(1000000n);
const rate = Uint128(105n);  // 5% as 105/100
const base = Uint128(100n);

// Interest after 10 periods
const multiplier = Uint128.toPower(rate, Uint128(10n));
const amount = Uint128.times(principal, multiplier);
const result = Uint128.dividedBy(amount, Uint128.toPower(base, Uint128(10n)));

// 128-bit feature flags
const FLAG_A = Uint128(1n << 0n);
const FLAG_B = Uint128(1n << 1n);
const FLAG_C = Uint128(1n << 127n);

let flags = Uint128.ZERO;
flags = Uint128.bitwiseOr(flags, FLAG_A);
flags = Uint128.bitwiseOr(flags, FLAG_C);

// Check flag
const hasA = !Uint128.isZero(Uint128.bitwiseAnd(flags, FLAG_A));
const hasB = !Uint128.isZero(Uint128.bitwiseAnd(flags, FLAG_B));

import * as Uint128 from 'tevm/Uint128';
import * as Uint64 from 'tevm/Uint64';

const a = Uint128(100n);
const b = Uint64(50n);

// Type error: cannot mix Uint128 and Uint64
// const sum = Uint128.plus(a, b);  // ❌

// Convert first
const converted = Uint128(Uint64.toBigInt(b));
const sum = Uint128.plus(a, converted);  // ✅