arbsys.mini

//
// Copyright 2020, Offchain Labs, Inc. All rights reserved.
//

use evmCallStack::EvmCallFrame;
use std::bytearray::ByteArray;

use chainParameters::chainParams_chainId;

use evmCallStack::evmCallStack_stackDepth;
use evmCallStack::evmCallStack_topFrame;
use evmCallStack::evmCallStack_setAccount;
use evmCallStack::evmCallStack_getTopFrameMemoryOrDie;
use evmCallStack::evmCallStack_setTopFrameMemory;
use evmCallStack::evmCallStack_callHitError;
use evmCallStack::evmCallStack_inRetryable;
use evmCallStack::evmCallStack_getRealCallerInfo;

use evmCallStack::evmCallFrame_getCalldata;
use evmCallStack::evmCallFrame_getCallvalue;
use evmCallStack::evmCallFrame_getAccount;
use evmCallStack::evmCallFrame_runningAsAddress;
use evmCallStack::evmCallFrame_getCaller;
use evmCallStack::evmCallFrame_getReservedStorageGas;

use evmOps::evmOp_log4;
use evmOps::evmOp_return;
use evmOps::evmOp_revert_knownPc;
use evmOps::evmOp_revert_knownCodePc;
use evmOps::evmOp_sload;
use evmOps::evmOp_sstore;
use evmOps::evmOp_revertIfStatic;

use accounts::account_getNextSeqNum;
use accounts::account_getStorageCell;
use accounts::account_deductFromEthBalance;

use std::bytearray::bytearray_new;
use std::bytearray::bytearray_size;
use std::bytearray::bytearray_setByte;
use std::bytearray::bytearray_get256;
use std::bytearray::bytearray_set256;
use std::bytearray::bytearray_extract;
use std::bytearray::bytearray_copy;

use std::safeMath::safeAdd;
use std::safeMath::safeMul;

use inbox::inbox_currentArbBlockNumber;
use inbox::inbox_currentEthBlockNumber;
use inbox::inbox_currentTimestamp;
use inbox::mapL1SenderAddress;

use gasAccounting::gasAccounting_getCurrentStorageGasAvailable;

use output::queueMessageForSend;


public view write throw func arbsys_txcall() {
    if let Some(topFrame) = evmCallStack_topFrame() {
        let calldata = evmCallFrame_getCalldata(topFrame);
        if bytearray_size(calldata) < 4 {
            evmOp_revert_knownCodePc(address(const::Address_ArbSys), 0, 0, 0);
        }
        let funcCode = getFuncCode(calldata);
        if funcCode == const::funcCode_ArbSys_arbOSVersion {
            arbsys_arbOSVersion(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_arbChainID {
            arbsys_arbChainID(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_arbBlockNumber {
            arbsys_arbBlockNumber(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_withdrawEth {
            arbsys_withdrawEth(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_sendTxToL1 {
            arbsys_sendTxToL1(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_getTransactionCount {
            arbsys_getTransactionCount(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_getStorageAt {
            arbsys_getStorageAt(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_isTopLevelCall {
            arbsys_isTopLevelCall(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_wasMyCallersAddressAliased {
            arbsys_wasMyCallersAddressAliased(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_myCallersAddressWithoutAliasing {
            arbsys_myCallersAddressWithoutAliasing(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_mapL1SenderContractAddressToL2Alias {
            arbsys_mapL1SenderContractAddressToL2Alias(topFrame, calldata);
        } else if funcCode == const::funcCode_ArbSys_getStorageGasAvailable {
            arbsys_getStorageGasAvailable(topFrame, calldata);
        } else {
            // unrecognized function code
            evmOp_revert_knownCodePc(address(const::Address_ArbSys), 1, 0, 0);
        }
    } else {
        // this shouldn't happen -- should always be called in an EVM tx
        evmCallStack_callHitError(21);
    }
}

func getFuncCode(ba: ByteArray) -> uint {
    (bytearray_get256(ba, 0) >> 224)
}

public func arbosVersion() -> uint {
    const::ArbosVersionNumber
}

// function arbOSVersion() external pure returns (uint);
view write throw func arbsys_arbOSVersion(_topFrame: EvmCallFrame, calldata: ByteArray) {
    if bytearray_size(calldata) != 4 {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 5, 0, 0);
    }
    let version = arbosVersion();
    if evmCallStack_setTopFrameMemory(bytearray_set256(bytearray_new(0), 0, version)) {
        evmOp_return(0, 32);
    } else {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 6, 0, 0);
    }
}

// function arbChainID() external view returns(uint);
view write throw func arbsys_arbChainID(_topFrame: EvmCallFrame, calldata: ByteArray) {
    if bytearray_size(calldata) != 4 {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 7, 0, 0);
    }
    let chainId = chainParams_chainId();
    if evmCallStack_setTopFrameMemory(bytearray_set256(bytearray_new(0), 0, chainId)) {
        evmOp_return(0, 32);
    } else {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 8, 0, 0);
    }
}

// function arbBlockNumber() external view returns (uint);
view write throw func arbsys_arbBlockNumber(_topFrame: EvmCallFrame, calldata: ByteArray) {
    if bytearray_size(calldata) != 4 {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 6, 0, 0);
    }
    let blockNum = inbox_currentArbBlockNumber();
    if evmCallStack_setTopFrameMemory(bytearray_set256(bytearray_new(0), 0, blockNum)) {
        evmOp_return(0, 32);
    } else {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 7, 0, 0);
    }
}

// function withdrawEth(address destination) external payable returns(uint);
view write throw func arbsys_withdrawEth(topFrame: EvmCallFrame, calldata: ByteArray) {
    evmOp_revertIfStatic();
    if bytearray_size(calldata) != 36 {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 30, 0, 0);
    }
    let senderAddr = evmCallFrame_getCaller(topFrame);
    let destAddr = address(bytearray_get256(calldata, 4));
    let amount = evmCallFrame_getCallvalue(topFrame);

    let runningAsAddr = evmCallFrame_runningAsAddress(topFrame);
    let runningAsAccount = evmCallFrame_getAccount(topFrame, runningAsAddr);
    if let Some(updatedAcct) = account_deductFromEthBalance(runningAsAccount, amount) {
        if ! evmCallStack_setAccount(runningAsAddr, updatedAcct) {
            evmOp_revert_knownCodePc(address(const::Address_ArbSys), 31, 0, 0);
        }

        let uniqueId = sendTxToL1(senderAddr, destAddr, amount, bytearray_new(0));
        if evmCallStack_setTopFrameMemory(bytearray_set256(bytearray_new(0), 0, uniqueId)) {
            evmOp_return(0, 32);
        } else {
            evmOp_revert_knownCodePc(address(const::Address_ArbSys), 32, 0, 0);
        }
    } else {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 33, 0, 0);
    }
}

// function sendTxToL1(address destination, bytes calldata calldataForL1) external payable returns(uint);
view write throw func arbsys_sendTxToL1(topFrame: EvmCallFrame, calldata: ByteArray) {
    evmOp_revertIfStatic();
    let destAddr = address(bytearray_get256(calldata, 4));
    let nbytes = bytearray_get256(calldata, 4+2*32);
    let expectedCalldataSize = safeAdd(4 + 3*32, safeMul(32, safeAdd(nbytes, 31) / 32));
    if bytearray_size(calldata) != expectedCalldataSize {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 224, 0, 0);
    }
    let innerCalldata = bytearray_extract(calldata, 4+3*32, nbytes);

    let caller = evmCallFrame_getCaller(topFrame);
    let callvalue = evmCallFrame_getCallvalue(topFrame);
    let runningAsAddr = evmCallFrame_runningAsAddress(topFrame);
    let runningAsAccount = evmCallFrame_getAccount(topFrame, runningAsAddr);
    if let Some(updatedAcct) = account_deductFromEthBalance(runningAsAccount, callvalue) {
        if ! evmCallStack_setAccount(runningAsAddr, updatedAcct) {
            evmOp_revert_knownCodePc(address(const::Address_ArbSys), 220, 0, 0);
        }

        let uniqueId = sendTxToL1(caller, destAddr, callvalue, innerCalldata);
        if evmCallStack_setTopFrameMemory(bytearray_set256(bytearray_new(0), 0, uniqueId)) {
            evmOp_return(0, 32);
        } else {
            evmOp_revert_knownCodePc(address(const::Address_ArbSys), 222, 0, 0);
        }
    } else {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 223, 0, 0);
    }
}

view write throw func sendTxToL1(caller: address, destination: address, callvalue: uint, calldata: ByteArray) -> uint {
    let calldataSize = bytearray_size(calldata);
    queueMessageForSend(
        bytearray_copy(
            calldata,
            0,
            bytearray_set256(
                bytearray_set256(
                    bytearray_set256(
                        bytearray_set256(
                            bytearray_set256(
                                bytearray_set256(
                                    bytearray_setByte(
                                        bytearray_new(0),
                                        0,
                                        const::SendType_sendTxToL1
                                    ),
                                    1,
                                    uint(caller),
                                ),
                                32+1,
                                uint(destination),
                            ),
                            2*32+1,
                            inbox_currentArbBlockNumber(),
                        ),
                        3*32+1,
                        inbox_currentEthBlockNumber(),
                    ),
                    4*32+1,
                    inbox_currentTimestamp(),
                ),
                5*32+1,
                callvalue,
            ),
            6*32+1,
            calldataSize,
        ),
    );

    // write log data into memory
    let mem = bytearray_set256(
        bytearray_set256(
            bytearray_set256(
                bytearray_set256(
                    bytearray_set256(
                        bytearray_set256(
                            bytearray_set256(
                                bytearray_set256(
                                    bytearray_new(0),
                                    0,
                                    uint(caller),
                                ),
                                32,
                                0,  // item number in batch will be filled in later
                            ),
                            2*32,
                            inbox_currentArbBlockNumber(),
                        ),
                        3*32,
                        inbox_currentEthBlockNumber(),
                    ),
                    4*32,
                    inbox_currentTimestamp(),
                ),
                5*32,
                callvalue,
            ),
            6*32,
            7*32,  // offset to beginning of bytes size
        ),
        7*32,
        calldataSize,
    );

    mem = bytearray_copy(
        calldata,
        0,
        mem,
        8*32,
        32*((calldataSize+31)/32),
    );

    let savedMem = evmCallStack_getTopFrameMemoryOrDie();

    if ! evmCallStack_setTopFrameMemory(mem) {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 230, 0, 0);
    }

    let uniqueId = evmOp_sload(0);
    evmOp_sstore(0, uniqueId + 1);

    evmOp_log4(
        0,
        bytearray_size(mem),
        const::eventTopic_ArbSys_L2ToL1Transaction,
        uint(destination),
        uniqueId,
        0,    // batch number will be filled in later
    );

    if ! evmCallStack_setTopFrameMemory(savedMem) {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 231, 0, 0);
    }

    uniqueId
}

// function getTransactionCount(address account) external view returns(uint256);
view write throw func arbsys_getTransactionCount(topFrame: EvmCallFrame, calldata: ByteArray) {
    if bytearray_size(calldata) != 36 {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 40, 0, 0);
    }
    let addr = address(bytearray_get256(calldata, 4));
    let seqNum = account_getNextSeqNum(evmCallFrame_getAccount(topFrame, addr));
    let updatedMem = bytearray_set256(
         evmCallStack_getTopFrameMemoryOrDie(),
         0,
         seqNum
     );
    let success = evmCallStack_setTopFrameMemory(updatedMem);
    if success {
        evmOp_return(0, 32);
    } else {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 41, 0, 0);
    }
}

// function getStorageAt(address account, uint256 index) external view returns (uint256);
view write throw func arbsys_getStorageAt(topFrame: EvmCallFrame, calldata: ByteArray) {
    let senderAddr = evmCallFrame_getCaller(topFrame);
    if senderAddr != address(0) {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 50, 0, 0);
    }

    let addr = address(bytearray_get256(calldata, 4));
    let offset = bytearray_get256(calldata, 4+32);
    let acct = evmCallFrame_getAccount(topFrame, addr);

    let ret = if let Some(val) = account_getStorageCell(acct, offset) {
        val
    } else {
        0
    };

    let updatedMem = bytearray_set256(evmCallStack_getTopFrameMemoryOrDie(), 0, ret);
    let success = evmCallStack_setTopFrameMemory(updatedMem);

    if success {
        evmOp_return(0, 32);
    } else {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 51, 0, 0);
    }
}

// function isTopLevelCall() external view returns (bool);
view write throw func arbsys_isTopLevelCall(_topFrame: EvmCallFrame, calldata: ByteArray) {
    if bytearray_size(calldata) != 4 {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 70, 0, 0);
    }
    let depth = evmCallStack_stackDepth();
    let mem = bytearray_set256(
        bytearray_new(0),
        0,
        uint( (depth == 2) || ((depth == 3) && evmCallStack_inRetryable()) ),
    );
    if evmCallStack_setTopFrameMemory(mem) {
        evmOp_return(0, 32);
    } else {
        evmOp_revert_knownCodePc(address(const::Address_ArbSys), 71, 0, 0);
    }
}

// function wasMyCallersAddressAliased() external view returns (bool);
view write throw func arbsys_wasMyCallersAddressAliased(_topFrame: EvmCallFrame, calldata: ByteArray) {
    if bytearray_size(calldata) != 4 {
        evmOp_revert_knownPc(80, 0, 0);
    }
    if let Some(res) = evmCallStack_getRealCallerInfo(1) {
        let (_, b) = res;
        let mem = bytearray_set256(bytearray_new(0), 0, if b { 1 } else { 0 });
        if evmCallStack_setTopFrameMemory(mem) {
            evmOp_return(0, 32);
        } else {
            evmOp_revert_knownPc(81, 0, 0);
        }
    } else {
        evmOp_revert_knownPc(82, 0, 0);
    }
}

// function myCallersAddressWithoutAliasing() external view returns (address);
view write throw func arbsys_myCallersAddressWithoutAliasing(_topFrame: EvmCallFrame, calldata: ByteArray) {
    if bytearray_size(calldata) != 4 {
        evmOp_revert_knownPc(85, 0, 0);
    }
    if let Some(res) = evmCallStack_getRealCallerInfo(1) {
        let (addr, _) = res;
        let mem = bytearray_set256(bytearray_new(0), 0, uint(addr));
        if evmCallStack_setTopFrameMemory(mem) {
            evmOp_return(0, 32);
        } else {
            evmOp_revert_knownPc(86, 0, 0);
        }
    } else {
        evmOp_revert_knownPc(87, 0, 0);
    }
}

view write throw func arbsys_mapL1SenderContractAddressToL2Alias(_topFrame: EvmCallFrame, calldata: ByteArray) {
    if bytearray_size(calldata) != 4 + 2*32 {
        evmOp_revert_knownPc(90, 0, 0);
    }
    let sender = address(bytearray_get256(calldata, 4));
    let dest = address(bytearray_get256(calldata, 36));
    let mem = bytearray_set256(
        bytearray_new(0),
        0,
        uint(mapL1SenderAddress(sender, Some(dest))),
    );
    if evmCallStack_setTopFrameMemory(mem) {
        evmOp_return(0, 32);
    } else {
        evmOp_revert_knownPc(91, 0, 0);
    }
}

view write throw func arbsys_getStorageGasAvailable(topFrame: EvmCallFrame, calldata: ByteArray) {
    if bytearray_size(calldata) != 4 {
        evmOp_revert_knownPc(100, 0, 0);
    }
    let thisFrameStorageGas = gasAccounting_getCurrentStorageGasAvailable();
    let parentReservedStorageGas = if let Some(parentFrame) = topFrame.parent {
        evmCallFrame_getReservedStorageGas(parentFrame)
    } else {
        0
    };
    let mem = bytearray_set256(bytearray_new(0), 0, thisFrameStorageGas + parentReservedStorageGas);
    if evmCallStack_setTopFrameMemory(mem) {
        evmOp_return(0, 32);
    } else {
        evmOp_revert_knownPc(101, 0, 0);
    }
}