Contract Source Code:

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0 <0.9.0;

library Errors {

    string internal constant ETH_BALANCE_0 = 'EB0';
    string internal constant INSUFFICIENT_EXECUTION_FEE = 'IEF';
    string internal constant INVALID_OP_GAS_TOKEN = 'IOGT';
    string internal constant ONLY_EXECUTOR = 'OE';
    string internal constant ONLY_EXECUTOR_OR_OWNER = 'OEO';
    string internal constant OWNER_ALREADY_SET = 'OAS';
    string internal constant TRANSFER_ETH_FAIL = 'TEF';
    string internal constant WRONG_TOKEN_IN_AMOUNT = 'WTIA';
    string internal constant WRONG_TOKEN_OUT_AMOUNT = 'WTOA';

}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0 <0.9.0;

interface IManager {

    function getGateway(uint256 gatewayIdx) external view returns (address);

    function smartAccountTemplate() external view returns (address);

    function smartAccountImplementation() external view returns (address);

    function isExecutor(address executor) external view returns (bool);

    function getSmartAccount(address owner) external view returns (address);

    function getOpGasTokens() external view returns (address[] memory);

    function getOpGases() external view returns(uint256[6][] memory);

    function getOpGas(uint256 bIndex, uint256 opIndex) external view returns (uint256);

    function setGateways(address[] memory gateways) external;

    function addExecutor(address executor) external;

    function removeExecutor(address executor) external;

    function setOpGasTokens(address[] memory tokens) external;

    function setOpGases(uint256[6][] memory opGases) external;

}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0 <0.9.0;

import '../manager/IManager.sol';
import '../library/Errors.sol';
import './SmartAccountStorage.sol';

contract SmartAccount is SmartAccountStorage {

    address public immutable manager;

    constructor (address manager_) {
        manager = manager_;
    }

    function implementation() public view returns (address) {
        return IManager(manager).smartAccountImplementation();
    }

    function setOwner(address owner_) external {
        require(owner == address(0), Errors.OWNER_ALREADY_SET);
        owner = owner_;
    }

    fallback() external payable {
        address imp = implementation();
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), imp, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }

    receive() external payable {}

}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0 <0.9.0;

abstract contract SmartAccountStorage {

    address public owner;

}