Contract Address Details

// File: bitpost-contracts/contracts-common/interfaces/access/IOwnable.sol



pragma solidity ^0.8.20;

interface IOwnable {
    error OwnableUnauthorized(address sender, address owner);
    error OwnableInvalidOwner(address owner);
    
    function getOwner() external view returns(address);
    function setOwner(address owner) external;
}

// File: bitpost-contracts/contracts-vm/interfaces/IVersionManager.sol



pragma solidity ^0.8.20;


interface IVersionManager is IOwnable {
    error VersionManagerInvalidCid(uint16 cid);
    
    function getImplementation(uint16 cid) external view returns(address);
    function setImplementation(uint16 cid, address implementation) external;
    function newContract(uint16 cid) external returns(address);
}

// File: bitpost-contracts/contracts-common/contracts/upgrade/Upgradeable.sol



pragma solidity ^0.8.20;


abstract contract Upgradeable {
    /// @custom:storage-location erc7201:bitpost.common.Upgradeable
    struct Storage_Upgradeable {
        IVersionManager versionManager;
        uint16 cid;
    }
    
    // keccak256(abi.encode(uint256(keccak256("bitpost.common.Upgradeable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant STORAGE_LOCATION_UPGRADEABLE = 0x828626e98fd64181cb42e58a50c4931f9ea11da1800ee5ae64b4a2a58285ae00;
    
    function _init_Upgradeable(IVersionManager versionManager, uint16 cid) internal {
        Storage_Upgradeable storage $ = _getStorage_Upgradeable();
        $.versionManager = versionManager;
        $.cid = cid;
    }
    
    function _getVersionManager() internal view returns(IVersionManager) {
        Storage_Upgradeable storage $ = _getStorage_Upgradeable();
        return $.versionManager;
    }
    
    function _getCid() internal view returns(uint16) {
        Storage_Upgradeable storage $ = _getStorage_Upgradeable();
        return $.cid;
    }
    
    function _getStorage_Upgradeable() private pure returns(Storage_Upgradeable storage $) {
        assembly {
            $.slot := STORAGE_LOCATION_UPGRADEABLE
        }
    }
}

// File: bitpost-contracts/contracts-common/contracts/access/Ownable.sol



pragma solidity ^0.8.20;


abstract contract Ownable is IOwnable {
    /// @custom:storage-location erc7201:bitpost.common.Ownable
    struct Storage_Ownable {
        address owner;
    }
    
    // keccak256(abi.encode(uint256(keccak256("bitpost.common.Ownable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant STORAGE_LOCATION_OWNABLE = 0xbfdc26bbaea09886fc184fe4fcae59b15cffdf4b859be87d5955dbd541465600;
    
    modifier onlyOwner() {
        _checkOwner();
        _;
    }
    
    function _init_Ownable(address owner) internal {
        _setOwner(owner);
    }
    
    function getOwner() public view returns(address) {
        Storage_Ownable storage $ = _getStorage_Ownable();
        return $.owner;
    }
    
    function setOwner(address owner) external onlyOwner {
        _setOwner(owner);
    }
    
    function _setOwner(address owner) internal {
        require(owner != address(0), OwnableInvalidOwner(address(0)));
        Storage_Ownable storage $ = _getStorage_Ownable();
        $.owner = owner;
    }
    
    function _checkOwner() private view {
        Storage_Ownable storage $ = _getStorage_Ownable();
        require(msg.sender == $.owner, OwnableUnauthorized(msg.sender, $.owner));
    }
    
    function _getStorage_Ownable() private pure returns(Storage_Ownable storage $) {
        assembly {
            $.slot := STORAGE_LOCATION_OWNABLE
        }
    }
}

// File: bitpost-contracts/contracts-vm/contracts/VersionManager.sol



pragma solidity ^0.8.20;




contract VersionManager is IVersionManager, Ownable {
    /// @custom:storage-location erc7201:bitpost.vm.VersionManager
    struct Storage_VersionManager {
        mapping(uint16 => address) implementations;
    }
    
    // keccak256(abi.encode(uint256(keccak256("bitpost.vm.VersionManager")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant STORAGE_LOCATION_VERSIONMANAGER = 0x433f1e912c5d27d7a45609db3e669bf6cc6b4b451297228e4c27368efb8c2300;
    
    constructor() {
        _init_Ownable(msg.sender);
    }
    
    function getImplementation(uint16 cid) external view returns(address) {
        Storage_VersionManager storage $ = _getStorage_VersionManager();
        require($.implementations[cid] != address(0), VersionManagerInvalidCid(cid));
        return $.implementations[cid];
    }
    
    function setImplementation(uint16 cid, address implementation) external onlyOwner {
        Storage_VersionManager storage $ = _getStorage_VersionManager();
        $.implementations[cid] = implementation;
    }
    
    function newContract(uint16 cid) external returns(address) {
        Storage_VersionManager storage $ = _getStorage_VersionManager();
        require($.implementations[cid] != address(0), VersionManagerInvalidCid(cid));
        return address(new Proxy(this, cid));
    }
    
    function _getStorage_VersionManager() private pure returns(Storage_VersionManager storage $) {
        assembly {
            $.slot := STORAGE_LOCATION_VERSIONMANAGER
        }
    }
}

// File: bitpost-contracts/contracts-vm/contracts/proxy/Proxy.sol



pragma solidity ^0.8.20;



contract Proxy is Upgradeable {
    constructor(VersionManager versionManager, uint16 cid) {
        _init_Upgradeable(versionManager, cid);
    }
    
    fallback() external payable {
        address target = _getVersionManager().getImplementation(_getCid());
        
        // The target address is stored on the stack, not in memory, 
        // so it won't be affected by operations using memory offset 0.
        
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), target, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
}