ORIGIN (0x32)

[]

origin (uint160 as uint256)

stack.push(transaction.origin)

import { origin } from '@tevm/voltaire/evm/context';
import { createFrame } from '@tevm/voltaire/evm/Frame';
import * as Address from '@tevm/voltaire/primitives/Address';

// Transaction originated by this EOA
const originAddr = Address('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb');
const frame = createFrame({ stack: [] });

const err = origin(frame, originAddr);

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

contract ContractC {
    function check() public view returns (address txOrigin, address caller) {
        return (tx.origin, msg.sender);
    }
}

contract ContractB {
    function forward(ContractC c) public returns (address, address) {
        return c.check();
    }
}

contract ContractA {
    function start(ContractB b, ContractC c) public returns (address, address) {
        return b.forward(c);
    }
}

// Call chain: EOA (0xAAA) → A (0xBBB) → B (0xCCC) → C (0xDDD)
//
// In ContractC.check():
// - tx.origin = 0xAAA (EOA that started transaction)
// - msg.sender = 0xCCC (ContractB called us)

contract EventLogger {
    event Action(address indexed origin, address indexed sender, string action);

    function logAction(string memory action) public {
        emit Action(tx.origin, msg.sender, action);
        // tx.origin: Who initiated the transaction
        // msg.sender: Who called this contract
    }
}

contract GasRefunder {
    function expensiveOperation() public {
        // ... expensive operations ...

        // Refund gas to transaction originator
        uint256 gasUsed = gasleft();
        payable(tx.origin).transfer(gasUsed * tx.gasprice);
    }
}

// EXTREMELY DANGEROUS - DO NOT USE
contract Vulnerable {
    address public owner;

    function withdraw() public {
        require(tx.origin == owner, "Not owner");  // WRONG!
        payable(owner).transfer(address(this).balance);
    }
}

contract Attacker {
    Vulnerable victim;

    constructor(Vulnerable _victim) {
        victim = _victim;
    }

    function attack() public {
        // Trick the owner into calling this
        victim.withdraw();
    }
}

// Attack flow:
// 1. Owner (tx.origin) calls Attacker.attack()
// 2. Attacker.attack() calls Vulnerable.withdraw()
// 3. tx.origin == owner ✓ (passes the check!)
// 4. Funds are stolen

contract Safe {
    address public owner;

    function withdraw() public {
        require(msg.sender == owner, "Not owner");  // CORRECT!
        payable(owner).transfer(address(this).balance);
    }
}

User EOA (0xAAA) → Contract A (0xBBB) → Contract B (0xCCC)

In Contract B:
- tx.origin = 0xAAA (never changes)
- msg.sender = 0xBBB (Contract A called us)

// Attacker creates malicious contract
contract Phishing {
    Vulnerable target;

    function harmlessLooking() public {
        // Owner thinks this is safe to call
        // But it triggers the vulnerable withdraw
        target.withdraw();
        // tx.origin is still the owner, so it works!
    }
}

contract Relayer {
    function executeForUser(address target, bytes memory data) public {
        // Meta-transaction: we pay gas, user signs intent
        (bool success,) = target.call(data);
        require(success);

        // Charge the original user (who signed the transaction)
        // This is ONE OF THE RARE valid uses of tx.origin
        payable(tx.origin).transfer(calculateGasCost());
    }
}

contract BetterRelayer {
    function executeForUser(
        address user,
        address target,
        bytes memory data
    ) public {
        // Don't use tx.origin at all
        (bool success,) = target.call(data);
        require(success);

        payable(user).transfer(calculateGasCost());
    }
}

// Stack at maximum capacity
const frame = createFrame({ stack: new Array(1024).fill(0n) });
const err = origin(frame, originAddr);

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

// Insufficient gas
const frame = createFrame({ gasRemaining: 1n });
const err = origin(frame, originAddr);

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

// Theoretically invalid (can't sign transaction)
// but handled by EVM
const frame = createFrame({});
const err = origin(frame, Address('0x0000000000000000000000000000000000000000'));

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

// WRONG
require(tx.origin == owner);

// CORRECT
require(msg.sender == owner);

// WRONG
modifier onlyOwner() {
    require(tx.origin == owner);
    _;
}

// ACCEPTABLE
event UserAction(address indexed origin, string action);
emit UserAction(tx.origin, "purchased");

// Acceptable but prefer explicit parameters
function chargeUser() internal {
    payable(tx.origin).transfer(gasCost);
}