MUL (0x02)

a (top)
b

(a * b) mod 2^256

result = (a * b) & ((1 << 256) - 1)

import { mul } from '@tevm/voltaire/evm/arithmetic';
import { createFrame } from '@tevm/voltaire/evm/Frame';

// 5 * 10 = 50
const frame = createFrame({ stack: [5n, 10n] });
const err = mul(frame);

console.log(frame.stack); // [50n]
console.log(frame.gasRemaining); // Original - 5

// Large multiplication overflows
const MAX = (1n << 256n) - 1n;
const frame = createFrame({ stack: [MAX, 2n] });
const err = mul(frame);

// Result: Only lower 256 bits kept
// (MAX * 2) mod 2^256 = 2^256 - 2 = MAX - 1
console.log(frame.stack); // [MAX - 1n]

// Multiplying by 2 is left shift
const frame = createFrame({ stack: [0x0Fn, 2n] });
const err = mul(frame);

console.log(frame.stack); // [0x1En] (15 * 2 = 30)

// Multiplying by 1
const frame = createFrame({ stack: [42n, 1n] });
const err = mul(frame);

console.log(frame.stack); // [42n]

// Multiplying by 0
const frame = createFrame({ stack: [42n, 0n] });
const err = mul(frame);

console.log(frame.stack); // [0n]

// MAX * MAX overflows significantly
const MAX = (1n << 256n) - 1n;
const frame = createFrame({ stack: [MAX, MAX] });
mul(frame);

// Only lower 256 bits: (2^256-1)^2 mod 2^256 = 1
console.log(frame.stack); // [1n]

// Squaring a number
const frame = createFrame({ stack: [12n, 12n] });
mul(frame);

console.log(frame.stack); // [144n]

// Efficient scaling
const frame = createFrame({ stack: [100n, 1n << 10n] }); // * 1024
mul(frame);

console.log(frame.stack); // [102400n]

// Not enough stack items
const frame = createFrame({ stack: [5n] });
const err = mul(frame);

console.log(err); // { type: "StackUnderflow" }

// 18 decimal fixed-point multiplication
uint256 constant WAD = 1e18;

function wmul(uint256 x, uint256 y) pure returns (uint256) {
    return (x * y) / WAD;
}

// Example: 1.5 * 2.5 = 3.75
// (1.5e18 * 2.5e18) / 1e18 = 3.75e18

// Calculate 5% fee
function calculateFee(uint256 amount) pure returns (uint256) {
    return (amount * 5) / 100;
}

// Calculate with basis points (0.01%)
function feeInBps(uint256 amount, uint256 bps) pure returns (uint256) {
    return (amount * bps) / 10000;
}

// Rectangle area
function area(uint256 width, uint256 height) pure returns (uint256) {
    return width * height;
}

// Cube volume
function volume(uint256 side) pure returns (uint256) {
    return side * side * side;
}

// Convert tokens between decimal precisions
function convertDecimals(
    uint256 amount,
    uint8 fromDecimals,
    uint8 toDecimals
) pure returns (uint256) {
    if (fromDecimals > toDecimals) {
        return amount / (10 ** (fromDecimals - toDecimals));
    } else {
        return amount * (10 ** (toDecimals - fromDecimals));
    }
}

import { describe, it, expect } from 'vitest';
import { mul } from './0x02_MUL.js';

describe('MUL (0x02)', () => {
  it('multiplies two numbers', () => {
    const frame = createFrame([5n, 10n]);
    expect(mul(frame)).toBeNull();
    expect(frame.stack).toEqual([50n]);
  });

  it('handles overflow wrapping', () => {
    const MAX = (1n << 256n) - 1n;
    const frame = createFrame([MAX, 2n]);
    expect(mul(frame)).toBeNull();
    expect(frame.stack).toEqual([MAX - 1n]);
  });

  it('squares numbers correctly', () => {
    const frame = createFrame([12n, 12n]);
    expect(mul(frame)).toBeNull();
    expect(frame.stack).toEqual([144n]);
  });

  it('handles multiplication by zero', () => {
    const frame = createFrame([42n, 0n]);
    expect(mul(frame)).toBeNull();
    expect(frame.stack).toEqual([0n]);
  });

  it('handles multiplication by one', () => {
    const frame = createFrame([42n, 1n]);
    expect(mul(frame)).toBeNull();
    expect(frame.stack).toEqual([42n]);
  });

  it('returns StackUnderflow with insufficient stack', () => {
    const frame = createFrame([5n]);
    expect(mul(frame)).toEqual({ type: 'StackUnderflow' });
  });

  it('consumes correct gas (5)', () => {
    const frame = createFrame([5n, 10n], 100n);
    expect(mul(frame)).toBeNull();
    expect(frame.gasRemaining).toBe(95n);
  });
});

// VULNERABLE: No overflow protection
function calculateShares(uint256 price, uint256 quantity) returns (uint256) {
    return price * quantity;  // Can overflow!
}

// Attacker calls: calculateShares(2^200, 2^100)
// Expected: Massive value
// Actual: Overflows to small value, attacker pays less

function calculateShares(uint256 price, uint256 quantity) returns (uint256) {
    uint256 result = price * quantity;
    require(price == 0 || result / price == quantity, "overflow");
    return result;
}

// WRONG: Intermediate overflow
function wmul(uint256 x, uint256 y) pure returns (uint256) {
    return (x * y) / WAD;  // x * y can overflow!
}

function wmul(uint256 x, uint256 y) pure returns (uint256 z) {
    // Use assembly to get full 512-bit intermediate result
    assembly {
        if iszero(or(iszero(x), eq(div(mul(x, y), x), y))) {
            revert(0, 0)  // Overflow
        }
        z := div(mul(x, y), WAD)
    }
}

// Avoids overflow completely
function mulDivDown(uint256 x, uint256 y, uint256 denominator)
    pure returns (uint256 z) {
    assembly {
        // Equivalent to (x * y) / denominator with 512-bit intermediate
        z := div(mul(x, y), denominator)

        // Check for overflow: require(denominator > 0 &&
        //   (x == 0 || (x * y) / x == y))
        if iszero(and(
            gt(denominator, 0),
            or(iszero(x), eq(div(mul(x, y), x), y))
        )) { revert(0, 0) }
    }
}

// Automatic overflow checks
function multiply(uint256 a, uint256 b) pure returns (uint256) {
    return a * b;  // Reverts on overflow
}

// Explicit wrapping when needed
function unsafeMultiply(uint256 a, uint256 b) pure returns (uint256) {
    unchecked {
        return a * b;  // Uses raw MUL, wraps on overflow
    }
}

// Prefer MUL over repeated ADD
uint256 result = x * 10;  // 5 gas

// Instead of:
uint256 result = x + x + x + x + x + x + x + x + x + x;  // 30 gas