@paimaexample/evm-contracts 0.3.0

package/src/contracts/GenericPayment.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "./ERC1967.sol";
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+
+/// @dev Facilitates accepting payment that accepts extra data to know what the payment was for inside a Paima dApp.
+contract GenericPayment is ERC1967, OwnableUpgradeable {
+    /// @dev True if contract has been initialized via the `initialize` function.
+    bool public initialized;
+
+    using Address for address payable;
+
+    /// @dev Emitted when the contract is initialized.
+    event Initialized(address indexed owner);
+
+    /// @dev Emitted when payment of `amount` if made by `payer` with `message`.
+    event Pay(uint256 amount, address payer, string message);
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @dev Initializes the contracts, transferring ownership to the specified `owner`.
+    /// Callable only once.
+    /// Emits the `Initialized` event.
+    function initialize(address owner) public initializer {
+        require(!initialized, "Contract already initialized");
+        initialized = true;
+
+        __Ownable_init(owner);
+
+        emit Initialized(owner);
+    }
+
+    /// @dev Transfers native tokens to the contract, providing `message`.
+    /// Emits the `Pay` event.
+    function pay(string calldata message) external payable {
+        emit Pay(msg.value, msg.sender, message);
+    }
+
+    /// @dev Withdraws the contract balance to `_account`.
+    /// Callable only by the contract owner.
+    function withdraw(address payable _account) external onlyOwner {
+        uint256 balance = address(this).balance;
+
+        require(balance > 0, "GenericPayment: 0 balance");
+        _account.sendValue(balance);
+    }
+
+    /// @dev Upgrades the contract implementation to `_newContract`.
+    /// Callable only by the contract owner.
+    function upgradeContract(address _newContract) external onlyOwner {
+        _setImplementation(_newContract);
+    }
+}

package/src/contracts/NativeNftSale.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "./AnnotatedMintNft.sol";
+import "./BaseState.sol";
+import "./ERC1967.sol";
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+
+/// @dev Facilitates selling NFTs that accepts extra data when buying for any initialization data needed in a Paima dApp.
+contract NativeNftSale is BaseState, ERC1967, OwnableUpgradeable {
+    using Address for address payable;
+
+    /// @dev Emitted when the contract is initialized.
+    event Initialized(address indexed owner, address indexed nft);
+
+    /// @dev Emitted when the NFT price is updated from `oldPrice` to `newPrice`.
+    event UpdatePrice(uint256 indexed oldPrice, uint256 indexed newPrice);
+
+    /// @dev Emitted when an NFT of `tokenId` is minted to `receiver` by `buyer` paying `PRICE` in native tokens.
+    event BuyNFT(
+        uint256 indexed tokenId,
+        uint256 indexed PRICE,
+        address indexed receiver,
+        address buyer
+    );
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @dev Initializes the contract with the requested price `_price` in native tokens for specified NFT `_nft`,
+    /// transferring ownership to the specified `owner`.
+    /// Callable only once.
+    /// Emits the `Initialized` event.
+    function initialize(address owner, address _nft, uint256 _price) public virtual initializer {
+        require(!initialized, "Contract already initialized");
+        initialized = true;
+
+        nftPrice = _price;
+        nftAddress = _nft;
+        __Ownable_init(owner);
+
+        emit Initialized(owner, _nft);
+    }
+
+    /// @dev Purchases NFT for address `receiverAddress`, paying required price in native token.
+    /// This function calls the `mint` function on the `AnnotatedMintNft` contract, passing provided `initialData`.
+    /// Emits the `BuyNFT` event.
+    function buyNft(
+        address receiverAddress,
+        // not calldata to allow other contracts to wrap this and change what is bought with their own logic
+        string memory initialData
+    ) public payable returns (uint256) {
+        require(msg.value == nftPrice, "NativeNftSale: incorrect value");
+        require(receiverAddress != address(0), "NativeNftSale: zero receiver address");
+
+        uint256 price = nftPrice;
+
+        uint256 tokenId = AnnotatedMintNft(nftAddress).mint(receiverAddress, initialData);
+
+        emit BuyNFT(tokenId, price, receiverAddress, msg.sender);
+
+        return tokenId;
+    }
+
+    /// @dev Changes the sale price to `_nftPrice`.
+    /// Callable only by the contract owner.
+    /// Emits the `UpdatePrice` event.
+    function updatePrice(uint256 _nftPrice) external onlyOwner {
+        uint256 oldPrice = nftPrice;
+        nftPrice = _nftPrice;
+
+        emit UpdatePrice(oldPrice, _nftPrice);
+    }
+
+    /// @dev Withdraws the contract balance to `_account`.
+    /// Callable only by the contract owner.
+    function withdraw(address payable _account) external onlyOwner {
+        uint256 balance = address(this).balance;
+
+        require(balance > 0, "NativeNftSale: 0 balance");
+        _account.sendValue(balance);
+    }
+
+    /// @dev Upgrades the contract implementation to `_newContract`.
+    /// Callable only by the contract owner.
+    function upgradeContract(address _newContract) external onlyOwner {
+        _setImplementation(_newContract);
+    }
+
+    /// @dev Function allowing the contract to receive native tokens.
+    receive() external payable {}
+}

package/src/contracts/PaimaL2Contract.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/utils/Address.sol";
+
+/// @dev The main L2 contract for a Paima L2.
+contract PaimaL2Contract {
+    using Address for address payable;
+
+    /// @dev Emitted when `paimaSubmitGameInput` function is called with `data`.
+    /// `userAddress` is the transaction sender and `value` is the transaction value.
+    event PaimaGameInteraction(address indexed userAddress, bytes data, uint256 value);
+
+    /// @dev Contract owner.
+    address public owner;
+    /// @dev Amount in wei that is required to be paid when calling `paimaSubmitGameInput`.
+    uint256 public fee; // in wei
+
+    /// @dev Sets the contract owner to `_owner` and payment fee to `_fee`.
+    constructor(address _owner, uint256 _fee) {
+        owner = _owner;
+        fee = _fee;
+    }
+
+    /// @dev Emits the `PaimaGameInteraction` event, logging the `msg.sender`, `data`, and `msg.value`.
+    /// Revert if `msg.value` is less than set `fee`.
+    function paimaSubmitGameInput(bytes calldata data) public payable {
+        require(msg.value >= fee, "Sufficient funds required to submit game input");
+        emit PaimaGameInteraction(msg.sender, data, msg.value);
+    }
+
+    /// @dev Withdraws the contract balance to the `owner`.
+    /// Callable only by the contract owner.
+    function withdrawFunds() public {
+        require(msg.sender == owner, "Only owner can withdraw funds");
+        address payable to = payable(owner);
+        uint256 balance = address(this).balance;
+        to.sendValue(balance);
+    }
+
+    /// @dev Sets the `newOwner` as the contract owner.
+    /// Callable only by the contract owner.
+    function setOwner(address newOwner) public {
+        require(msg.sender == owner, "Only owner can change owner");
+        owner = newOwner;
+    }
+
+    /// @dev Sets the `newFee` as the required payment fee.
+    /// Callable only by the contract owner.
+    function setFee(uint256 newFee) public {
+        require(msg.sender == owner, "Only owner can change fee");
+        fee = newFee;
+    }
+}

package/src/contracts/Proxy/Erc20NftSaleProxy.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../ERC1967.sol";
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+/// @title Proxy
+/// @dev Proxy contract mostly based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/Proxy.sol
+contract Erc20NftSaleProxy is ERC1967 {
+    /// @dev Sets `implementation` address and calls the `Erc20NftSale.initialize` function with the parameters
+    /// `currencies`, `owner`, `nftAddress`, `nftPrice`.
+    constructor(
+        address implementation,
+        ERC20[] memory currencies,
+        address owner,
+        address nftAddress,
+        uint256 nftPrice
+    ) {
+        _assertCorrectImplementationSlot();
+        _setImplementation(implementation);
+
+        bytes memory data = abi.encodeWithSignature(
+            "initialize(address[],address,address,uint256)",
+            currencies,
+            owner,
+            nftAddress,
+            nftPrice
+        );
+        (bool success, ) = implementation.delegatecall(data);
+        require(success, "Initialization unsuccessful");
+    }
+
+    /// @dev Delegates the current call to `implementation`.
+    /// This function does not return to its internal call site, it will return
+    /// directly to the external caller.
+    function _delegate(address target) internal {
+        assembly {
+            // Copy msg.data. We take full control of memory in this inline assembly
+            // block because it will not return to Solidity code. We overwrite the
+            // Solidity scratch pad at memory position 0.
+            calldatacopy(0, 0, calldatasize())
+
+            // Call the implementation.
+            // out and outsize are 0 because we don't know the size yet.
+            let result := delegatecall(gas(), target, 0, calldatasize(), 0, 0)
+
+            // Copy the returned data.
+            returndatacopy(0, 0, returndatasize())
+
+            switch result
+            // delegatecall returns 0 on error.
+            case 0 {
+                revert(0, returndatasize())
+            }
+            default {
+                return(0, returndatasize())
+            }
+        }
+    }
+
+    /// @dev Delegates the current call to the address returned by `_implementation()`.
+    /// This function does not return to its internal call site, it will return
+    /// directly to the external caller.
+    function _fallback() internal {
+        _delegate(_getImplementation());
+    }
+
+    /// @dev Fallback function that delegates calls to the address returned by `_implementation()`.
+    /// Will run if no other function in the contract matches the call data.
+    fallback() external payable {
+        _fallback();
+    }
+
+    /// @dev Called if this contract is receiving native tokens and `msg.data` is empty
+    receive() external payable {}
+}

package/src/contracts/Proxy/GenericPaymentProxy.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../ERC1967.sol";
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+/// @title Proxy
+/// @dev Proxy contract mostly based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/Proxy.sol
+contract GenericPaymentProxy is ERC1967 {
+    /// @dev Sets `implementation` address and calls the `GenericPayment.initialize` function with the parameter
+    /// `owner`.
+    constructor(address implementation, address owner) {
+        _assertCorrectImplementationSlot();
+        _setImplementation(implementation);
+
+        bytes memory data = abi.encodeWithSignature("initialize(address)", owner);
+        (bool success, ) = implementation.delegatecall(data);
+        require(success, "Initialization unsuccessful");
+    }
+
+    /// @dev Delegates the current call to `implementation`.
+    /// This function does not return to its internal call site, it will return
+    /// directly to the external caller.
+    function _delegate(address target) internal {
+        assembly {
+            // Copy msg.data. We take full control of memory in this inline assembly
+            // block because it will not return to Solidity code. We overwrite the
+            // Solidity scratch pad at memory position 0.
+            calldatacopy(0, 0, calldatasize())
+
+            // Call the implementation.
+            // out and outsize are 0 because we don't know the size yet.
+            let result := delegatecall(gas(), target, 0, calldatasize(), 0, 0)
+
+            // Copy the returned data.
+            returndatacopy(0, 0, returndatasize())
+
+            switch result
+            // delegatecall returns 0 on error.
+            case 0 {
+                revert(0, returndatasize())
+            }
+            default {
+                return(0, returndatasize())
+            }
+        }
+    }
+
+    /// @dev Delegates the current call to the address returned by `_implementation()`.
+    /// This function does not return to its internal call site, it will return
+    /// directly to the external caller.
+    function _fallback() internal {
+        _delegate(_getImplementation());
+    }
+
+    /// @dev Fallback function that delegates calls to the address returned by `_implementation()`.
+    /// Will run if no other function in the contract matches the call data.
+    fallback() external payable {
+        _fallback();
+    }
+}

package/src/contracts/Proxy/NativeNftSaleProxy.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../ERC1967.sol";
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+/// @title Proxy
+/// @dev Proxy contract mostly based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/Proxy.sol
+contract NativeNftSaleProxy is ERC1967 {
+    /// @dev Sets `implementation` address and calls the `NativeNftSale.initialize` function with the parameters
+    /// `owner`, `nftAddress`, `nftPrice`.
+    constructor(address implementation, address owner, address nftAddress, uint256 nftPrice) {
+        _assertCorrectImplementationSlot();
+        _setImplementation(implementation);
+
+        bytes memory data = abi.encodeWithSignature(
+            "initialize(address,address,uint256)",
+            owner,
+            nftAddress,
+            nftPrice
+        );
+        (bool success, ) = implementation.delegatecall(data);
+        require(success, "Initialization unsuccessful");
+    }
+
+    /// @dev Delegates the current call to `implementation`.
+    /// This function does not return to its internal call site, it will return
+    /// directly to the external caller.
+    function _delegate(address target) internal {
+        assembly {
+            // Copy msg.data. We take full control of memory in this inline assembly
+            // block because it will not return to Solidity code. We overwrite the
+            // Solidity scratch pad at memory position 0.
+            calldatacopy(0, 0, calldatasize())
+
+            // Call the implementation.
+            // out and outsize are 0 because we don't know the size yet.
+            let result := delegatecall(gas(), target, 0, calldatasize(), 0, 0)
+
+            // Copy the returned data.
+            returndatacopy(0, 0, returndatasize())
+
+            switch result
+            // delegatecall returns 0 on error.
+            case 0 {
+                revert(0, returndatasize())
+            }
+            default {
+                return(0, returndatasize())
+            }
+        }
+    }
+
+    /// @dev Delegates the current call to the address returned by `_implementation()`.
+    /// This function does not return to its internal call site, it will return
+    /// directly to the external caller.
+    function _fallback() internal {
+        _delegate(_getImplementation());
+    }
+
+    /// @dev Fallback function that delegates calls to the address returned by `_implementation()`.
+    /// Will run if no other function in the contract matches the call data.
+    fallback() external payable {
+        _fallback();
+    }
+
+    /// @dev Called if this contract is receiving native tokens and `msg.data` is empty
+    receive() external payable {}
+}

package/src/contracts/Proxy/OrderbookDexProxy.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+
+/// @title Proxy contract for OrderbookDex
+contract OrderbookDexProxy is ERC1967Proxy {
+    constructor(
+        address _implementation,
+        address _owner,
+        uint256 _defaultMakerFee,
+        uint256 _defaultTakerFee,
+        uint256 _orderCreationFee
+    )
+        ERC1967Proxy(
+            _implementation,
+            abi.encodeWithSignature(
+                "initialize(address,uint256,uint256,uint256)",
+                _owner,
+                _defaultMakerFee,
+                _defaultTakerFee,
+                _orderCreationFee
+            )
+        )
+    {}
+}

package/src/contracts/README.md

@@ -0,0 +1,72 @@
+# Solidity Contracts
+
+Solidity contracts provided as part of Paima Engine.
+
+Core contracts
+
+<ul>
+  <li>[PaimaL2Contract](#PaimaL2Contract): The main L2 contract for a Paima L2.</li>
+</ul>
+State-annotated contracts
+<ul>
+  <li>[AnnotatedMintNft](#AnnotatedMintNft): A standard ERC721 that accepts calldata in the mint function for any initialization data needed in a Paima dApp.</li>
+  <li>[InverseBaseProjectedNft](#InverseBaseProjectedNft): Project game state into a ERC721 NFT on an EVM layer initiated on said base layer.</li>
+  <li>[InverseAppProjectedNft](#InverseAppProjectedNft): Project game state into a ERC721 NFT on an EVM layer initiated on the app layer.</li>
+  <li>[InverseBaseProjected1155](#InverseBaseProjected1155): Project game state into a ERC1155 on an EVM layer initiated on said base layer.</li>
+  <li>[InverseAppProjected1155](#InverseAppProjected1155): Project game state into a ERC1155 on an EVM layer initiated on the app layer.</li>
+</ul>
+Facilitating monetization
+<ul>
+  <li>[NativeNftSale](#NativeNftSale): Facilitates selling NFTs that accepts extra data when buying for any initialization data needed in a Paima dApp.</li>
+  <li>[GenericPayment](#GenericPayment): Facilitates accepting payment that accepts extra data to know what the payment was for inside a Paima dApp.</li>
+  <li>[Erc20NftSale](#Erc20NftSale): Facilitates selling NFTs for specific ERC20s that accepts extra data when buying for any initialization data needed in a Paima dApp.</li>
+  <li>[OrderbookDexProxy](#OrderbookDexProxy): Proxy for the orderbook DEX contract.</li>
+  <li>[IOrderbookDex](#IOrderbookDex): Interface to facilitate trading inverse projected ERC1155 tokens.</li>
+  <li>[OrderbookDex](#OrderbookDex): Facilitates trading inverse projected ERC1155 tokens.</li>
+</ul>
+
+## Core contracts
+
+{{PaimaL2Contract}}
+
+## State-annotated contracts
+
+{{AnnotatedMintNft}}
+
+{{IInverseProjectedNft}} {{IInverseBaseProjectedNft}}
+{{InverseBaseProjectedNft}} {{IInverseAppProjectedNft}}
+{{InverseAppProjectedNft}}
+
+{{IInverseProjected1155}} {{IInverseBaseProjected1155}}
+{{InverseBaseProjected1155}} {{IInverseAppProjected1155}}
+{{InverseAppProjected1155}}
+
+## Facilitating monetization
+
+{{NativeNftSale}}
+
+{{GenericPayment}}
+
+{{Erc20NftSale}}
+
+{{OrderbookDexProxy}}
+
+{{IOrderbookDex}}
+
+{{OrderbookDex}}
+
+## Utilities
+
+{{BaseState}}
+
+{{State}}
+
+{{IERC4906Agnostic}} {{ERC1967}}
+
+{{IUri}} {{ITokenUri}}
+
+{{NativeNftSaleProxy}}
+
+{{GenericPaymentProxy}}
+
+{{Erc20NftSaleProxy}}

package/src/contracts/State.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract State {
+    /// @dev Required payment for the NFT in sale.
+    uint256 public nftPrice;
+
+    /// @dev True if contract has been initialized via `initialize` function.
+    bool public initialized;
+
+    /// @dev Address of the NFT for sale.
+    address public nftAddress;
+
+    /// @dev Array of addresses of tokens that have been deposited to the contract via NFT sales.
+    ERC20[] public depositedCurrencies;
+
+    /// @dev Mapping that returns true for address of token that has been deposited to the contract via NFT sale.
+    mapping(ERC20 => bool) public depositedCurrenciesMap;
+
+    /// @dev Array of addresses of tokens that are accepted as payment for the NFT sale.
+    ERC20[] public supportedCurrencies;
+}

package/src/contracts/dev/ERC721Dev.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+contract Erc721Dev is ERC721 {
+    constructor() ERC721("Mock ERC721", "MERC") {}
+
+    function mint(address _to, uint256 _tokenId) external {
+        _mint(_to, _tokenId);
+    }
+}

package/src/contracts/dev/Erc20Dev.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract Erc20Dev is ERC20 {
+    constructor() ERC20("Mock ERC20", "MERC") {}
+
+    function mint(address _to, uint256 _amount) external {
+        _mint(_to, _amount);
+    }
+}

package/src/contracts/dev/NativeNftSaleUpgradeDev.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../NativeNftSale.sol";
+import "./UpgradeDev.sol";
+
+/// @dev For testing upgradeability.
+contract NativeNftSaleUpgradeDev is UpgradeDev, NativeNftSale {}

package/src/contracts/dev/NftSaleUpgradeDev.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../Erc20NftSale.sol";
+
+/// @dev For testing upgradeability.
+contract NftSaleUpgradeDev is Erc20NftSale {
+    function version() public pure returns (uint8) {
+        return 2;
+    }
+}

package/src/contracts/dev/NftTypeMapper.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../NativeNftSale.sol";
+
+enum NftType {
+    FIRE,
+    WATER
+}
+
+contract NftTypeMapper {
+    mapping(NftType => string) internal nftTypeToString;
+
+    constructor() {
+        nftTypeToString[NftType.FIRE] = "fire";
+        nftTypeToString[NftType.WATER] = "water";
+    }
+
+    function getNftTypeString(NftType nftType) external view returns (string memory) {
+        return nftTypeToString[nftType];
+    }
+}
+
+contract TypedNativeNftSale is NativeNftSale {
+    NftTypeMapper public typeMapper;
+
+    function initialize(address owner, address _nft, uint256 _price) public override {
+        require(!initialized, "Contract already initialized");
+        // initialize state here first since parent constructor emits event
+        typeMapper = new NftTypeMapper();
+        super.initialize(owner, _nft, _price);
+    }
+
+    function buyNftType(address receiverAddress, NftType nftType) public payable returns (uint256) {
+        return super.buyNft(receiverAddress, typeMapper.getNftTypeString(nftType));
+    }
+}

package/src/contracts/dev/Token.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract Token is ERC20 {
+    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
+        _mint(msg.sender, 10000000e18);
+    }
+
+    function mint(address _to, uint256 _amount) external {
+        _mint(_to, _amount);
+    }
+}

package/src/contracts/dev/UpgradeDev.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+/// @dev For testing upgradeability.
+contract UpgradeDev {
+    function version() public pure returns (uint8) {
+        return 2;
+    }
+}