pluggables.mini

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

use accounts::Account;
use accounts::account_setContractInfo;

use evmCallStack::evmCallStack_topFrame;
use evmCallStack::evmCallStack_setTopFrameMemory;
use evmCallStack::evmCallFrame_getCalldata;

use evmOps::getEvmOpJumpTable;
use evmOps::evmOp_return;
use evmOps::evmOp_revert;

use core::array::array;
use core::array::array_resize;

use std::bytearray::ByteArray;
use std::bytearray::bytearray_new;
use std::bytearray::bytearray_size;
use std::bytearray::bytearray_setByte;

use std::storageMap::storageMap_new;

const ModuleIdLimit = 4096;


type ModuleFunction = impure func(any, any, bool, impure func(uint, any) -> option<any>) -> (any, any)

type ModuleState = struct {
    code: ModuleFunction,
    state: any,
    neverBeenCalled: bool,
}

type ModuleManager = struct {
    capacity: uint,
    modules: []option<ModuleState>,
}

var moduleManager: ModuleManager;

public impure func pluggables_init() {
    moduleManager = struct {
        capacity: 1,
        modules: newarray<option<ModuleState>>(1) with { [0] = None<ModuleState> },
    };
}

public impure func callPluggable(id: uint, args: any) -> option<any> {
    if (id >= moduleManager.capacity) {
        return None;
    }

    let theModule = moduleManager.modules[id]?;
    let (retVal, newState) = theModule.code(args, theModule.state, theModule.neverBeenCalled, callPluggable);

    moduleManager = moduleManager with {
        modules: moduleManager.modules with {
            [id] = Some(theModule with { state: newState } with { neverBeenCalled: false })
        }
    };
    return Some(retVal);
}

public impure func pluggableExists(id: uint) -> bool {
    return (id < moduleManager.capacity) && (moduleManager.modules[id] != None<ModuleState>);
}

public impure func installPluggable(id: uint, newFunc: ModuleFunction, keepState: bool) -> option<()> {
    if (id > const::ModuleIdLimit) {
        return None;
    }

    while (id >= moduleManager.capacity) {
        let newCapacity = 8 * moduleManager.capacity;
        moduleManager = moduleManager with {
            capacity: newCapacity
        } with {
            modules: unsafecast<[]option<ModuleState>>(
                array_resize(
                    unsafecast<array>(moduleManager.modules),
                    newCapacity,
                    None<ModuleState>
                )
            )
        };
    }

    let newState = unsafecast<any>(());
    if (keepState) {
        newState = (moduleManager.modules[id]?).state;
    }
    moduleManager = moduleManager with {
        modules: moduleManager.modules with {
            [id] = Some(struct { code: newFunc, state: newState, neverBeenCalled: true })
        }
    };

    return Some(());
}

// The next section supports binding pluggables to a contract address, so a pluggable can function as
//     a contract.
// A pluggable functioning this way expects to receive args consisting of the 3-tuple
//          (callFrame: EvmCallFrame, calldata: ByteArray, evmOpJumpTable: [const::NumEvmOps]impure func()).
// Its should return (success: bool, resultData: ByteArray).

public impure func bindContractAddressToPluggable(account: Account, id: uint) -> Account {
    return account_setContractInfo(
       account,
       bytearray_setByte(bytearray_new(0), 0, 0xfe),   // like an "Arbitrum style" precompiled contract
       newmap<uint, impure func()>,
       makePluggableContractEntryPoint(id),
       storageMap_new(),
       true,    // force initial nonce to be 1
    );
}

impure func makePluggableContractEntryPoint(id: uint) -> impure func() {
    // make a small code snippet that function-calls to entryPointForPluggableContract(id) (with a dummy return address)
    // using a dummy return address is safe because entryPointForPluggableContract will never return
    return asm(
        const::AVM_nop,
        id,
        asm(
            const::AVM_nop,
            0,    // dummy return address
            asm(
                const::AVM_jump,
                entryPointForPluggableContract,
                asm() func() { errcodept }
            ) func() { pushinsnimm }
        ) func() { pushinsnimm }
    ) impure func() { pushinsnimm };
}

impure func entryPointForPluggableContract(id: uint) {
    if let Some(topFrame) = evmCallStack_topFrame() {
        if let Some(retVal) = callPluggable(id, (topFrame, evmCallFrame_getCalldata(topFrame), getEvmOpJumpTable())) {
            let (success, resultData) = unsafecast<(bool, ByteArray)>(retVal);
            if (evmCallStack_setTopFrameMemory(resultData)) {
                if (success) {
                    evmOp_return(0, bytearray_size(resultData));
                } else {
                    evmOp_revert(0, bytearray_size(resultData));
                }
            }
        }
    }
    evmOp_revert(0, 0);
}