// This is the code Vault address will actually hold.

// a Diamond proxy with two ingrained functions
// implementation addresses will be stored on the last 2^32 slots. in other words, bitwise_not(msg.sig).
// the value will be either:
// 1. implementation address --> normal function
// 2. bitwise_not(implementation address) --> view function, implemented with the ingrained function 2

// on creation, it delegatecalls back to the caller.
// the caller is expected to initialize the storage.

// ingrained function 1: 'read' (0x72656164)
// a cheap way to read storage slots
// other contracts are expected to directly read predefined storage slots using this mechanism.
// expected calldata:
//    0x72656164 | bytes32 | bytes32 | bytes32 ... (no length header)
//    the query is interpreted as a series of storage slots.
// returns:
//    bytes32 | bytes32 | bytes32 | ....
//    returns storage values without header

// ingraned function 2: 'view' (0x76696577)
// delegatecall any contract; revert if the call didn't, and vice versa.
// used to calculate the result of a state-modifying function, without actually modifying the state.
// expected calldata: 0x76696577 | destination address padded to 32 bytes | calldata to be forwarded

contract Diamond {
    constructor() {
        assembly {
            let success := delegatecall(gas(), caller(), 0, 0, 0, 0)
            if iszero(success) { revert(0, 0) }
        }
    }

    fallback() external payable {
        assembly {
            if calldatasize() {
                let selector := shr(0xe0, calldataload(0x00))
                if eq(selector, 0x72656164) {
                    // 'read'
                    for { let i := 4 } lt(i, calldatasize()) { i := add(i, 0x20) } { mstore(i, sload(calldataload(i))) }
                    return(4, sub(calldatasize(), 4))
                }
                if eq(selector, 0x76696577) {
                    // view
                    calldatacopy(0, 36, sub(calldatasize(), 36))
                    let success := delegatecall(gas(), calldataload(4), 0, sub(calldatasize(), 36), 0, 0)
                    returndatacopy(0, 0, returndatasize())
                    if success { revert(0, returndatasize()) }
                    return(0, returndatasize())
                }
                let implementation := sload(not(selector))
                if implementation {
                    if lt(implementation, 0x10000000000000000000000000000000000000000) {
                        // registered as a function
                        calldatacopy(0, 0, calldatasize())
                        let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
                        returndatacopy(0, 0, returndatasize())
                        switch result
                        case 0 { revert(0, returndatasize()) }
                        default { return(0, returndatasize()) }
                    }
                    // registered as a view function
                    mstore(0, 0x7669657700000000000000000000000000000000000000000000000000000000)
                    mstore(4, not(implementation))
                    calldatacopy(36, 0, calldatasize())
                    let success := delegatecall(gas(), address(), 0, add(calldatasize(), 36), 0, 0)
                    returndatacopy(0, 0, returndatasize())
                    if success { revert(0, returndatasize()) }
                    return(0, returndatasize())
                }
                revert(0, 0)
            }
        }
    }
}

{
  "remappings": [
    "@prb/test/=lib/prb-math/lib/prb-test/src/",
    "ds-test/=lib/solmate/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin/=lib/openzeppelin-contracts/contracts/",
    "openzeppelin-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@prb/math/=lib/prb-math/",
    "prb-test/=lib/prb-math/lib/prb-test/src/",
    "solmate/=lib/solmate/src/",
    "lzapp/=lib/solidity-examples/contracts/",
    "LayerZero/=lib/LayerZero/contracts/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "prb-math/=lib/prb-math/src/",
    "solidity-examples/=lib/solidity-examples/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 50
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": true,
  "libraries": {}
}

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"}]

0x60806040523461002857600080808080335af4156100255760405160f0908161002e8239f35b80fd5b600080fdfe608060405236600a57005b6000803560e01c63726561648114609c5763766965778114607e57195480602f575080fd5b81600160a01b821060675750637669657760e01b825219600452368160243780806024360181305af43d82803e6063573d90f35b3d90fd5b8091368280378136915af43d82803e156063573d90f35b50808036602319018060248337816004355af43d82803e6063573d90f35b60045b36811060ae5736600319016004f35b8035548152602001609f56fea2646970667358221220d8c23d04c5972f79fb49e01f5ef185ec3b1d237ac7e5882429911ee568ec4b3464736f6c63430008130033

0x608060405236600a57005b6000803560e01c63726561648114609c5763766965778114607e57195480602f575080fd5b81600160a01b821060675750637669657760e01b825219600452368160243780806024360181305af43d82803e6063573d90f35b3d90fd5b8091368280378136915af43d82803e156063573d90f35b50808036602319018060248337816004355af43d82803e6063573d90f35b60045b36811060ae5736600319016004f35b8035548152602001609f56fea2646970667358221220d8c23d04c5972f79fb49e01f5ef185ec3b1d237ac7e5882429911ee568ec4b3464736f6c63430008130033