@paimaexample/evm-contracts 0.3.0

package/src/companions/PaimaL2Contract.json

@@ -0,0 +1,134 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_owner",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_fee",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "userAddress",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "bytes",
+        "name": "data",
+        "type": "bytes"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "PaimaGameInteraction",
+    "type": "event"
+  },
+  {
+    "inputs": [],
+    "name": "fee",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "latestStoreHeight",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "owner",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "data",
+        "type": "bytes"
+      }
+    ],
+    "name": "paimaSubmitGameInput",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "withdrawFunds",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "setOwner",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "newFee",
+        "type": "uint256"
+      }
+    ],
+    "name": "setFee",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]

package/src/companions/PaimaL2Contract.ts

@@ -0,0 +1,134 @@
+export default [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_owner",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_fee",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "userAddress",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "data",
+        type: "bytes",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256",
+      },
+    ],
+    name: "PaimaGameInteraction",
+    type: "event",
+  },
+  {
+    inputs: [],
+    name: "fee",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    name: "latestStoreHeight",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes",
+      },
+    ],
+    name: "paimaSubmitGameInput",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "withdrawFunds",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newOwner",
+        type: "address",
+      },
+    ],
+    name: "setOwner",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "newFee",
+        type: "uint256",
+      },
+    ],
+    name: "setFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;

package/src/companions/README.md

@@ -0,0 +1,5 @@
+# Companion ABIs
+
+ABIs for contracts that are not written by the Paima team, but whose ABIs are
+useful either in conjunction to our contracts, or who are used by the Paima
+Engine itself.

package/src/contracts/AnnotatedMintNft.sol

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+
+/// @dev A standard ERC721 that accepts calldata in the mint function for any initialization data needed in a Paima dApp.
+/// Upon deployment only the contract owner (specified in constructor parameter) is able to mint tokens. Additional
+/// minters (e.g. NativeNftSale contract) need to be added by using the `setMinter` function.
+contract AnnotatedMintNft is ERC165, ERC721, Ownable {
+    /// @dev The token ID that will be minted when calling the `mint` function.
+    uint256 public currentTokenId;
+    /// @dev Base URI that is used in the `tokenURI` function to form the start of the token URI.
+    string public baseURI;
+    /// @dev Total token supply, increased by minting and decreased by burning.
+    uint256 public totalSupply;
+    /// @dev Maximum amount of tokens that is allowed to exist.
+    uint256 public maxSupply;
+    /// @dev Base extension that is used in the `tokenURI` function to form the end of the token URI.
+    string public baseExtension;
+
+    /// @dev Returns true for addresses that are allowed to mint this token.
+    mapping(address => bool) public minters;
+
+    /// @dev Reverts if `msg.sender` is neither a minter nor the contract owner.
+    modifier canMint() {
+        require(
+            isMinter(msg.sender) || owner() == msg.sender,
+            "AnnotatedMintNft: not authorized to mint"
+        );
+        _;
+    }
+
+    /// @dev Reverts if `msg.sender` is not the specified token's owner.
+    modifier onlyTokenOwner(uint256 tokenId) {
+        require(msg.sender == ownerOf(tokenId), "AnnotatedMintNft: not owner");
+        _;
+    }
+
+    /// @dev Emitted when max supply is updated from `oldMaxSupply` to `newMaxSupply`.
+    event UpdateMaxSupply(uint256 indexed oldMaxSupply, uint256 indexed newMaxSupply);
+
+    /// @dev Emitted when `newMinter` is added to the mapping of allowed `minters`.
+    event SetMinter(address indexed newMinter);
+
+    /// @dev Emitted when `oldMinter` is removed from the mapping of allowed `minters`
+    event RemoveMinter(address indexed oldMinter);
+
+    /// @dev Emitted when `baseUri` is updated from `oldUri` to `newUri`.
+    event SetBaseURI(string oldUri, string newUri);
+
+    /// @dev Emitted when a new token with ID `tokenId` is minted, with `initialData` provided in the `mint` function parameters.
+    event Minted(uint256 indexed tokenId, string initialData);
+
+    /// @dev Sets the NFT's `name`, `symbol`, `maxSupply` to `supply`, `currentTokenId` to 1 and `baseExtension` to `".json"`.
+    /// @param name Collection name.
+    /// @param symbol Collection symbol.
+    /// @param owner The owner of the contract, who will be able to execute
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint256 supply,
+        address owner
+    ) ERC721(name, symbol) Ownable(owner) {
+        maxSupply = supply;
+        currentTokenId = 1;
+        baseExtension = ".json";
+    }
+
+    /// @dev Returns true if this contract implements the interface defined by `interfaceID`. See EIP165.
+    function supportsInterface(
+        bytes4 interfaceID
+    ) public view override(ERC165, ERC721) returns (bool) {
+        return super.supportsInterface(interfaceID) || interfaceID == this.mint.selector;
+    }
+
+    /// @dev Mints a new token to address `_to`, passing `initialData` to be emitted in the event.
+    /// Increases the `totalSupply` and `currentTokenId`.
+    /// Reverts if `totalSupply` is not less than `maxSupply` or if `_to` is a zero address.
+    /// Emits the `Minted` event.
+    function mint(address _to, string calldata initialData) external canMint returns (uint256) {
+        require(maxSupply > totalSupply, "AnnotatedMintNft: max supply reached");
+        require(_to != address(0), "AnnotatedMintNft: zero receiver address");
+
+        uint256 tokenId = currentTokenId;
+        _safeMint(_to, tokenId);
+
+        totalSupply++;
+        currentTokenId++;
+
+        emit Minted(tokenId, initialData);
+        return tokenId;
+    }
+
+    /// @dev Burns token of ID `_tokenId`. Callable only by the owner of the specified token.
+    /// Reverts if `_tokenId` is not existing.
+    function burn(uint256 _tokenId) external onlyTokenOwner(_tokenId) {
+        totalSupply--;
+        _burn(_tokenId);
+    }
+
+    /// @dev Adds `_minter` to the mapping of allowed `minters` of this NFT.
+    /// Callable only by the contract owner.
+    /// Emits the `SetMinter` event.
+    function setMinter(address _minter) external onlyOwner {
+        require(_minter != address(0), "AnnotatedMintNft: invalid minter");
+
+        minters[_minter] = true;
+        emit SetMinter(_minter);
+    }
+
+    /// @dev Removes `_minter` from the mapping of allowed `minters` of this NFT.
+    /// Callable only by the contract owner.
+    /// Emits the `RemoveMinter` event.
+    function removeMinter(address _minter) external onlyOwner {
+        require(_minter != address(0), "AnnotatedMintNft: invalid minter");
+
+        minters[_minter] = false;
+        emit RemoveMinter(_minter);
+    }
+
+    /// @dev Returns the `baseURI` of this NFT.
+    function _baseURI() internal view override returns (string memory) {
+        return baseURI;
+    }
+
+    /// @dev Returns the token URI of specified `tokenId`.
+    function tokenURI(uint256 tokenId) public view override returns (string memory) {
+        string memory URI = super.tokenURI(tokenId);
+        return string(abi.encodePacked(URI, baseExtension));
+    }
+
+    /// @dev Sets `_URI` as the `baseURI` of the NFT.
+    /// Callable only by the contract owner.
+    /// Emits the `SetBaseURI` event.
+    function setBaseURI(string memory _URI) external onlyOwner {
+        string memory oldURI = baseURI;
+        baseURI = _URI;
+        emit SetBaseURI(oldURI, _URI);
+    }
+
+    /// @dev Sets `_newBaseExtension` as the `baseExtension` of the NFT.
+    /// Callable only by the contract owner.
+    function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
+        baseExtension = _newBaseExtension;
+    }
+
+    /// @dev Sets `_maxSupply` as the `maxSupply` of the NFT.
+    /// Callable only by the contract owner.
+    /// Emits the `UpdateMaxSupply` event.
+    function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
+        uint256 oldMaxSupply = maxSupply;
+        require(_maxSupply > oldMaxSupply, "AnnotatedMintNft: old supply less than new supply");
+
+        maxSupply = _maxSupply;
+        emit UpdateMaxSupply(oldMaxSupply, _maxSupply);
+    }
+
+    /// @dev Returns true if specified `_tokenId` exists.
+    function exists(uint256 _tokenId) external view returns (bool) {
+        return _ownerOf(_tokenId) != address(0);
+    }
+
+    /// @dev Returns true if `_account` is in the mapping of allowed `minters`.
+    function isMinter(address _account) public view returns (bool) {
+        return minters[_account];
+    }
+}

package/src/contracts/BaseState.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract BaseState {
+    /// @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;
+}

package/src/contracts/ERC1967.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/utils/Address.sol";
+import "@openzeppelin/contracts/utils/StorageSlot.sol";
+
+/// @title ERC1967
+/// @dev ERC1967 contract providing randomized implementation storage slot
+/// Made as a small subset of https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/ERC1967/ERC1967Upgrade.sol
+abstract contract ERC1967 {
+    /**
+     * @dev Storage slot with the address of the current implementation.
+     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
+     * validated in the constructor.
+     */
+    bytes32 internal constant _IMPLEMENTATION_SLOT =
+        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+
+    /**
+     * @dev Assert that value of `_IMPLEMENTATION_SLOT` matches expected value
+     */
+    function _assertCorrectImplementationSlot() internal pure {
+        assert(
+            _IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1)
+        );
+    }
+
+    /**
+     * @dev Returns the current implementation address.
+     */
+    function _getImplementation() internal view returns (address) {
+        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
+    }
+
+    /**
+     * @dev Stores a new address in the EIP1967 implementation slot.
+     */
+    function _setImplementation(address newImplementation) internal {
+        require(newImplementation.code.length > 0, "ERC1967: new implementation is not a contract");
+        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
+    }
+}

package/src/contracts/Erc20NftSale.sol

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "./AnnotatedMintNft.sol";
+import "./State.sol";
+import "./ERC1967.sol";
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+/// @dev Facilitates selling NFTs for specific ERC20s that accepts extra data when buying for any initialization data needed in a Paima dApp.
+contract Erc20NftSale is State, ERC1967, OwnableUpgradeable {
+    /// @dev Emitted when the contract is initialized.
+    event Initialized(ERC20[] indexed currencies, 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 the `token` is removed from the list of `supportedCurrencies`.
+    event RemoveWhitelistedToken(address indexed token);
+
+    /// @dev Emitted when the `tokens` are added as the `supportedCurrencies`.
+    event WhitelistTokens(address[] indexed tokens);
+
+    /// @dev Emitted when an NFT of `tokenId` is minted to `receiver` by `buyer` paying `PRICE` in tokens of `supportedCurrencies`.
+    event BuyWithToken(
+        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 tokens of `currencies` for specified NFT `_nft`,
+    /// transferring ownership to the specified `owner`.
+    /// Callable only once.
+    /// Emits the `Initialized` event.
+    function initialize(
+        ERC20[] memory currencies,
+        address owner,
+        address _nft,
+        uint256 _price
+    ) public virtual initializer {
+        require(!initialized, "Contract already initialized");
+        initialized = true;
+
+        for (uint8 i = 0; i < currencies.length; i++) {
+            supportedCurrencies.push(currencies[i]);
+        }
+
+        nftPrice = _price;
+        nftAddress = _nft;
+        __Ownable_init(owner);
+
+        emit Initialized(currencies, owner, _nft);
+    }
+
+    /// @dev Purchases NFT for address `receiverAddress`, paying required price in token of `_tokenAddress`,
+    /// if it is one of the `supportedCurrencies`.
+    /// This function calls the `mint` function on the `AnnotatedMintNft` contract, passing provided `initialData`.
+    /// Emits the `BuyWithToken` event.
+    function buyWithToken(
+        ERC20 _tokenAddress,
+        address receiverAddress,
+        // not calldata to allow other contracts to wrap this and change what is bought with their own logic
+        string memory initialData
+    ) public virtual returns (uint256) {
+        require(tokenIsWhitelisted(_tokenAddress), "Erc20NftSale: token not whitelisted");
+        require(receiverAddress != address(0), "Erc20NftSale: zero receiver address");
+
+        uint256 price = nftPrice;
+
+        // transfer tokens from buyer to contract
+        ERC20(_tokenAddress).transferFrom(msg.sender, address(this), price);
+
+        uint256 tokenId = AnnotatedMintNft(nftAddress).mint(receiverAddress, initialData);
+
+        if (!depositedCurrenciesMap[_tokenAddress]) {
+            depositedCurrencies.push(_tokenAddress);
+            depositedCurrenciesMap[_tokenAddress] = true;
+        }
+
+        emit BuyWithToken(tokenId, price, receiverAddress, msg.sender);
+
+        return tokenId;
+    }
+
+    /// @dev Removes `_token` from the list of `supportedCurrencies`.
+    /// Callable only by the contract owner.
+    /// Emits the `RemoveWhitelistedToken` event.
+    function removeWhitelistedToken(ERC20 _token) external onlyOwner {
+        require(tokenIsWhitelisted(_token), "Erc20NftSale: token not whitelisted");
+
+        ERC20[] memory supportedCurrenciesMem = supportedCurrencies;
+
+        uint256 tokenIndex;
+        for (uint256 i = 0; i < supportedCurrenciesMem.length; i++) {
+            if (supportedCurrenciesMem[i] == _token) {
+                tokenIndex = i;
+                break;
+            }
+        }
+
+        require(tokenIndex < supportedCurrenciesMem.length, "Erc20NftSale: out of bounds");
+
+        supportedCurrencies[tokenIndex] = supportedCurrencies[supportedCurrencies.length - 1];
+        supportedCurrencies.pop();
+
+        emit RemoveWhitelistedToken(address(_token));
+    }
+
+    /// @dev Adds `_tokens` to the `supportedCurrencies` array.
+    /// Callable only by the contract owner.
+    /// Emits the `WhitelistTokens` event.
+    function whitelistTokens(ERC20[] memory _tokens) external onlyOwner {
+        address[] memory newWhiteList = new address[](_tokens.length);
+
+        for (uint256 i = 0; i < _tokens.length; i++) {
+            newWhiteList[i] = address(_tokens[i]);
+            supportedCurrencies.push(_tokens[i]);
+        }
+
+        emit WhitelistTokens(newWhiteList);
+    }
+
+    /// @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 of `depositedCurrencies` to `_account`.
+    /// Callable only by the contract owner.
+    function withdraw(address _account) external onlyOwner {
+        ERC20[] memory currencies = depositedCurrencies;
+
+        for (uint256 i = 0; i < currencies.length; ) {
+            uint256 balance = currencies[i].balanceOf(address(this));
+            if (balance > 0) {
+                currencies[i].transfer(_account, balance);
+            }
+
+            depositedCurrenciesMap[currencies[i]] = false;
+
+            unchecked {
+                i++;
+            }
+        }
+
+        delete depositedCurrencies;
+    }
+
+    /// @dev Upgrades the contract implementation to `_newContract`.
+    /// Callable only by the contract owner.
+    function upgradeContract(address _newContract) external onlyOwner {
+        _setImplementation(_newContract);
+    }
+
+    /// @dev Returns true if `_token` is part of the `supportedCurrencies`.
+    function tokenIsWhitelisted(ERC20 _token) public view returns (bool) {
+        ERC20[] memory supportedCurrenciesMem = supportedCurrencies;
+        for (uint256 i = 0; i < supportedCurrenciesMem.length; i++) {
+            if (supportedCurrenciesMem[i] == _token) return true;
+        }
+
+        return false;
+    }
+
+    /// @dev Returns the token addresses that have been used as a payment in the NFT purchases.
+    function getDepositedCurrencies() public view returns (ERC20[] memory) {
+        return depositedCurrencies;
+    }
+
+    /// @dev Returns an array of token addresses that are accepted as payment in the NFT purchase.
+    function getSupportedCurrencies() public view returns (ERC20[] memory) {
+        return supportedCurrencies;
+    }
+}