LT (0x10)

a (top)
b

a < b ? 1 : 0

result = (a < b) ? 1 : 0

import { lt } from '@tevm/voltaire/evm/comparison';
import { createFrame } from '@tevm/voltaire/evm/Frame';

// 5 < 10 = 1 (true)
const frame = createFrame({ stack: [5n, 10n] });
const err = lt(frame);

console.log(frame.stack); // [1n]
console.log(frame.gasRemaining); // Original - 3

// 20 < 20 = 0 (false)
const frame = createFrame({ stack: [20n, 20n] });
const err = lt(frame);

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

// 30 < 20 = 0 (false)
const frame = createFrame({ stack: [30n, 20n] });
const err = lt(frame);

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

// 0 < 1 = 1 (true)
const frame = createFrame({ stack: [0n, 1n] });
lt(frame);
console.log(frame.stack); // [1n]

// 1 < 0 = 0 (false)
const frame2 = createFrame({ stack: [1n, 0n] });
lt(frame2);
console.log(frame2.stack); // [0n]

// (2^256 - 2) < (2^256 - 1) = 1 (true)
const MAX = (1n << 256n) - 1n;
const frame = createFrame({ stack: [MAX - 1n, MAX] });
lt(frame);

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

// 2^255 is treated as large positive (not negative)
const SIGN_BIT = 1n << 255n;

// 1 < 2^255 = 1 (true, unsigned comparison)
const frame = createFrame({ stack: [1n, SIGN_BIT] });
lt(frame);

console.log(frame.stack); // [1n]
// In signed comparison (SLT), this would be 0 because 2^255 = -2^255 (negative)

const MAX = (1n << 256n) - 1n;

// 0 < MAX = 1
lt(createFrame({ stack: [0n, MAX] }));  // [1n]

// MAX < 0 = 0
lt(createFrame({ stack: [MAX, 0n] }));  // [0n]

// MAX < MAX = 0
lt(createFrame({ stack: [MAX, MAX] }));  // [0n]

// Values with bit 255 set are large positive (unsigned)
const SIGN_BIT = 1n << 255n;  // 2^255

// SIGN_BIT is treated as 2^255, not -2^255
// 2^255 < 1 = 0 (false, unsigned)
lt(createFrame({ stack: [SIGN_BIT, 1n] }));  // [0n]

// Compare with SLT (signed):
// SLT would return 1 because 2^255 = -2^255 < 1 (signed)

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

console.log(err); // { type: "StackUnderflow" }
console.log(frame.stack); // [5n] (unchanged)

// Insufficient gas
const frame = createFrame({ stack: [5n, 10n], gasRemaining: 2n });
const err = lt(frame);

console.log(err); // { type: "OutOfGas" }
console.log(frame.gasRemaining); // 0n

// Arbitrary precision supported
const a = 123456789012345678901234567890n;
const b = 987654321098765432109876543210n;

const frame = createFrame({ stack: [a, b] });
lt(frame);

console.log(frame.stack); // [1n] (a < b)

// require(index < length)
assembly {
    if iszero(lt(index, length)) {
        revert(0, 0)
    }
}

// Check if value < max
assembly {
    let valid := lt(value, max)
    if iszero(valid) {
        revert(0, 0)
    }
}

// for (uint i = 0; i < n; i++)
assembly {
    let i := 0
    for {} lt(i, n) { i := add(i, 1) } {
        // Loop body
    }
}

// min(a, b)
assembly {
    let minimum := a
    if lt(b, a) {
        minimum := b
    }
}

// Safe array access
assembly {
    if lt(index, arrLength) {
        let value := sload(add(arrSlot, index))
        // Use value
    }
}

import { describe, it, expect } from 'vitest';
import { handle as LT } from './0x10_LT.js';

describe('LT (0x10)', () => {
  it('returns 1 when a < b', () => {
    const frame = createFrame([10n, 20n]);
    expect(LT(frame)).toBeNull();
    expect(frame.stack).toEqual([1n]);
    expect(frame.pc).toBe(1);
    expect(frame.gasRemaining).toBe(997n);
  });

  it('returns 0 when a >= b (equal)', () => {
    const frame = createFrame([20n, 20n]);
    expect(LT(frame)).toBeNull();
    expect(frame.stack).toEqual([0n]);
  });

  it('returns 0 when a > b', () => {
    const frame = createFrame([30n, 20n]);
    expect(LT(frame)).toBeNull();
    expect(frame.stack).toEqual([0n]);
  });

  it('handles 0 < 1', () => {
    const frame = createFrame([0n, 1n]);
    expect(LT(frame)).toBeNull();
    expect(frame.stack).toEqual([1n]);
  });

  it('handles max uint256 values', () => {
    const MAX = (1n << 256n) - 1n;
    const frame = createFrame([MAX - 1n, MAX]);
    expect(LT(frame)).toBeNull();
    expect(frame.stack).toEqual([1n]);
  });

  it('treats all values as unsigned', () => {
    // 2^255 is large positive as unsigned
    const SIGN_BIT = 1n << 255n;
    const frame = createFrame([1n, SIGN_BIT]);
    expect(LT(frame)).toBeNull();
    expect(frame.stack).toEqual([1n]); // 1 < 2^255
  });

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

  it('returns OutOfGas when insufficient gas', () => {
    const frame = createFrame([10n, 20n], 2n);
    expect(LT(frame)).toEqual({ type: 'OutOfGas' });
  });

  it('preserves stack below compared values', () => {
    const frame = createFrame([100n, 200n, 10n, 20n]);
    expect(LT(frame)).toBeNull();
    expect(frame.stack).toEqual([100n, 200n, 1n]);
  });
});

// VULNERABLE: Using LT for signed values
function withdraw(int256 amount) {
    // LT treats -1 as 2^256-1 (huge positive!)
    assembly {
        if lt(balance, amount) {  // WRONG!
            revert(0, 0)
        }
    }
    // Negative amounts bypass the check
}

// CORRECT: Use SLT for signed comparisons
function withdraw(int256 amount) {
    assembly {
        if slt(balance, amount) {  // Correct
            revert(0, 0)
        }
    }
}

// VULNERABLE: Wrong boundary
require(index <= array.length);  // Allows out-of-bounds!

// CORRECT: Strict less than
require(index < array.length);  // Max valid: length - 1

// VULNERABLE: Overflow corrupts comparison
uint256 sum = a + b;  // May wrap to small value
require(sum > a);     // Check may incorrectly pass

// CORRECT: Check before operation
require(a <= type(uint256).max - b);
uint256 sum = a + b;

// VULNERABLE: Comparing different widths
uint256 large = type(uint256).max;
uint128 small = type(uint128).max;

// Implicit cast may truncate
require(large < small);  // Type confusion

// CORRECT: Explicit same-width comparison
require(uint256(large) < uint256(small));

// These are equivalent:
// a < b  ===  !(a >= b)

assembly {
    // Direct
    let less := lt(a, b)

    // Inverted (sometimes useful in complex conditions)
    let less := iszero(or(gt(a, b), eq(a, b)))
}

// Evaluate cheapest condition first
assembly {
    if lt(index, length) {
        // Only check expensive condition if first passes
        if expensiveCheck() {
            // Execute
        }
    }
}

// Compiler may optimize constant comparisons
assembly {
    if lt(value, 100) {  // Constant 100
        // Optimized by EVM implementations
    }
}