Cha0s/dfd 82 Write an NFT contract.

.env.example

@@ -1,2 +1,4 @@
 RPC_URL=http://localhost:8545
-PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 
+PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 
+# From nft.storage account
+NFT_STORAGE_KEY=12345

.gitignore

@@ -2,4 +2,5 @@ cache/
 out/
 node_modules/
 broadcast/
-.env
+.env
+yarn-error.log

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/solmate"]
+	path = lib/solmate
+	url = https://github.com/transmissions11/solmate
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com/Openzeppelin/openzeppelin-contracts

foundry.toml

@@ -1,4 +1,4 @@
-[default]
+[profile.default]
 src = 'src'
 out = 'out'
 libs = ['lib']

metadata/grand_prix.js

@@ -0,0 +1,8 @@
+export default {
+  name: "Wallbreaker",
+  description: "Winners of the Eternal Grand Prix",
+  attributes: [
+    { trait_type: "Grand Prix", value: "Cumbersome Scrawny" },
+    { display_type: "number", trait_type: "Rank", value: 1 },
+  ],
+};

nft.mjs

@@ -0,0 +1,47 @@
+import { NFTStorage, File, Blob } from 'nft.storage'
+import fs from 'fs'
+import mime from 'mime'
+import path from 'path'
+import 'dotenv/config';
+import meta from './metadata/grand_prix.js';
+
+// read the API key from an environment variable. You'll need to set this before running the example!
+const API_KEY = process.env.NFT_STORAGE_KEY
+
+async function fileFromPath(filePath) {
+  const content = await fs.promises.readFile(filePath)
+  const type = mime.getType(filePath)
+  return new File([content], path.basename(filePath), { type })
+}
+
+
+async function storeExampleNFT() {
+  const args = process.argv.slice(2)
+
+  if (args.length !== 1) {
+    console.error(`usage: ${process.argv[0]} ${process.argv[1]} <image-path>`)
+    process.exit(1)
+  }
+  const [imagePath] = args
+
+  const image = await fileFromPath(imagePath)
+  const nft = {
+    image, // use image Blob as `image` field
+    ...meta
+  }
+  console.log(image instanceof Blob);
+
+  if(!API_KEY) throw new Error("no NFT STORAGE key found");
+  const client = new NFTStorage({ token: API_KEY })
+  console.log(`nft`, nft);
+  const metadata = await client.store(nft)
+  console.log('NFT data stored!')
+  console.log('Metadata URI: ', metadata.url)
+}
+
+storeExampleNFT()
+.catch(err => {
+    console.error(err)
+    process.exit(1)
+})
+

package.json

@@ -1,5 +1,6 @@
 {
   "name": "@dfdao/gp-registry",
+  "type": "module",
   "version": "1.0.0",
   "license": "GPL-3.0",
   "files": [
@@ -35,6 +36,11 @@
     "start:node": "anvil -m 'test test test test test test test test test test test junk'"
   },
   "dependencies": {
+    "cross-fetch": "^3.1.5",
+    "dotenv": "^16.0.1",
+    "mime": "^3.0.0",
+    "nft.storage": "^7.0.0",
+    "node-fetch": "^3.2.10",
     "run-pty": "^3.0.0",
     "wait-on": "^6.0.1"
   }

remappings.txt

@@ -0,0 +1,4 @@
+ds-test/=lib/solmate/lib/ds-test/src/
+forge-std/=lib/forge-std/src/
+openzeppelin-contracts/=lib/openzeppelin-contracts/
+solmate/=lib/solmate/src/

src/NFT.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.10;
+
+import "solmate/tokens/ERC721.sol";
+import "openzeppelin-contracts/contracts/utils/Strings.sol";
+import "openzeppelin-contracts/contracts/access/Ownable.sol";
+
+error MintPriceNotPaid();
+error MaxSupply();
+error NonExistentTokenURI();
+error WithdrawTransfer();
+error InvalidURI();
+
+contract NFT is ERC721, Ownable {
+    using Strings for uint256;
+    string public baseURI;
+    uint256 public currentTokenId;
+    mapping(uint256 => string) tokenURIs;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        string memory _baseURI
+    ) ERC721(_name, _symbol) {
+        baseURI = _baseURI;
+    }
+
+    function mintTo(address recipient, string memory _tokenURI)
+        public
+        payable
+        onlyOwner
+        returns (uint256)
+    {
+        if (bytes(baseURI).length == 0) revert InvalidURI();
+
+        uint256 newTokenId = ++currentTokenId;
+        tokenURIs[newTokenId] = _tokenURI;
+        _safeMint(recipient, newTokenId);
+        return newTokenId;
+    }
+
+    function bulkMintTo(address[] memory recipients, string memory _tokenURI)
+        public
+        payable
+        onlyOwner
+        returns (uint256[] memory)
+    {
+        uint256[] memory tokenIds = new uint[](recipients.length);
+
+        if (bytes(baseURI).length == 0) revert InvalidURI();
+        for(uint256 i; i < recipients.length; i++) {
+            uint256 newTokenId = ++currentTokenId;
+            tokenURIs[newTokenId] = _tokenURI;
+            _safeMint(recipients[i], newTokenId);
+            tokenIds[i] = newTokenId;
+        }
+
+        return tokenIds;
+    }
+
+    function tokenURI(uint256 tokenId)
+        public
+        view
+        virtual
+        override
+        returns (string memory)
+    {
+        if (ownerOf(tokenId) == address(0)) {
+            revert NonExistentTokenURI();
+        }
+        return bytes(baseURI).length > 0 ? tokenURIs[tokenId] : "";
+    }
+
+    function withdrawPayments(address payable payee) external onlyOwner {
+        uint256 balance = address(this).balance;
+        (bool transferTx, ) = payee.call{value: balance}("");
+        if (!transferTx) {
+            revert WithdrawTransfer();
+        }
+    }
+}

test/NFT.t.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.10;
+
+import "forge-std/Test.sol";
+import "forge-std/console.sol";
+import "../src/NFT.sol";
+
+contract NFTTest is Test {
+    using stdStorage for StdStorage;
+
+    NFT private nft;
+    string private tokenURI = "wee";
+
+    function setUp() public {
+        // Deploy NFT contract
+
+        nft = new NFT("NFT_tutorial", "TUT", "/Users/0x/darkforest/dfdao/arena/gp-registry/images/cutie.png");
+    }
+
+    function testURI() public {
+        uint256 tokenId = nft.mintTo{value: 0.08 ether}(address(1),tokenURI);
+        console.log("tokenUri", nft.tokenURI(tokenId));
+    }
+
+    function testMintNoPrice() public {
+        nft.mintTo(address(1),"");
+    }
+
+    function testFailMintToZeroAddress() public {
+        nft.mintTo{value: 0.08 ether}(address(0),tokenURI);
+    }
+
+    function testNewMintOwnerRegistered() public {
+        nft.mintTo{value: 0.08 ether}(address(1),tokenURI);
+        uint256 slotOfNewOwner = stdstore
+            .target(address(nft))
+            .sig(nft.ownerOf.selector)
+            .with_key(1)
+            .find();
+
+        uint160 ownerOfTokenIdOne = uint160(
+            uint256(
+                (vm.load(address(nft), bytes32(abi.encode(slotOfNewOwner))))
+            )
+        );
+        assertEq(address(ownerOfTokenIdOne), address(1),tokenURI);
+    }
+
+    function testBalanceIncremented() public {
+        nft.mintTo{value: 0.08 ether}(address(1),tokenURI);
+        uint256 slotBalance = stdstore
+            .target(address(nft))
+            .sig(nft.balanceOf.selector)
+            .with_key(address(1))
+            .find();
+
+        uint256 balanceFirstMint = uint256(
+            vm.load(address(nft), bytes32(slotBalance))
+        );
+        assertEq(balanceFirstMint, 1);
+
+        nft.mintTo{value: 0.08 ether}(address(1),tokenURI);
+        uint256 balanceSecondMint = uint256(
+            vm.load(address(nft), bytes32(slotBalance))
+        );
+        assertEq(balanceSecondMint, 2);
+    }
+
+    function testSafeContractReceiver() public {
+        Receiver receiver = new Receiver();
+        nft.mintTo{value: 0.08 ether}(address(receiver),tokenURI);
+        uint256 slotBalance = stdstore
+            .target(address(nft))
+            .sig(nft.balanceOf.selector)
+            .with_key(address(receiver))
+            .find();
+
+        uint256 balance = uint256(vm.load(address(nft), bytes32(slotBalance)));
+        assertEq(balance, 1);
+    }
+
+    function testFailUnSafeContractReceiver() public {
+        vm.etch(address(1), bytes("mock code"));
+        nft.mintTo{value: 0.08 ether}(address(1),tokenURI);
+    }
+
+
+}
+
+contract Receiver is ERC721TokenReceiver {
+    function onERC721Received(
+        address operator,
+        address from,
+        uint256 id,
+        bytes calldata data
+    ) external pure override returns (bytes4) {
+        return this.onERC721Received.selector;
+    }
+}
+