Foundry Book

使用 Solmate 创建 NFT

本教程将引导您使用 Foundry 和 Solmate 创建兼容 OpenSea 的 NFT。可以在此处找到本教程的完整实现。

本教程仅用于说明目的，并按原样提供。本教程未经审核或全面测试。不应在生产环境中使用本教程中的任何代码。

创建项目并安装依赖

按照入门部分中列出的步骤开始设置 Foundry 项目。我们还将为其 ERC721 实现安装 Solmate，以及一些 OpenZeppelin 实用程序库。通过从项目的根目录运行以下命令来安装依赖项：

forge install transmissions11/solmate Openzeppelin/openzeppelin-contracts

这些依赖项将作为 git 子模块添加到您的项目中。

如果您正确地按照说明进行操作，您的项目结构应该如下所示：

Project structure

实现一个基本的 NFT

然后我们将 src/Contract.sol 中的样板合同重命名为 src/NFT.sol 并替换代码：

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

import "solmate/tokens/ERC721.sol";
import "openzeppelin-contracts/utils/Strings.sol";

contract NFT is ERC721 {
    uint256 public currentTokenId;

    constructor(
        string memory _name,
        string memory _symbol
    ) ERC721(_name, _symbol) {}

    function mintTo(address recipient) public payable returns (uint256) {
        uint256 newItemId = ++currentTokenId;
        _safeMint(recipient, newItemId);
        return newItemId;
    }

    function tokenURI(uint256 id) public view virtual override returns (string memory) {
        return Strings.toString(id);
    }
}

让我们来看看 NFT 的这个非常基本的实现。我们首先从我们的 git 子模块中导入两个合约。我们导入了 solmate 的gas优化实施 ERC721 标准，我们的 NFT 合约将继承该标准。我们的构造函数为我们的 NFT 获取_name和_symbol参数，并将它们传递给父 ERC721 实现的构造函数。最后，我们实现了允许任何人铸造 NFT 的 mintTo 功能。此函数递增 currentTokenId 并使用我们父合约的 _safeMint 函数。

使用 forge 编译部署

要编译 NFT 合约，请运行forge build。由于映射错误，您可能会遇到构建失败的情况：

Error:
Compiler run failed
error[6275]: ParserError: Source "lib/openzeppelin-contracts/contracts/contracts/utils/Strings.sol" not found: File not found. Searched the following locations: "/PATH/TO/REPO".
 --> src/NFT.sol:5:1:
  |
5 | import "openzeppelin-contracts/contracts/utils/Strings.sol";
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

这可以通过设置正确的重映射来解决。在您的项目中创建一个文件 remappings.txt 并添加以下行

openzeppelin-contracts/=lib/openzeppelin-contracts/

（您可以在依赖文档中找到有关重新映射的更多信息。

默认情况下，编译器输出将位于 out目录中。要使用 Forge 部署我们编译好的合约，我们必须为 RPC 端点和我们要用于部署的私钥设置环境变量。

通过运行以下命令设置环境变量：

export RPC_URL=<你的 RPC 端点>
export PRIVATE_KEY=<你的钱包私钥>

设置完成后，您可以通过运行以下命令，同时将相关构造函数参数添加到 NFT 合约来使用 Forge 部署您的 NFT：

forge 创建 NFT --rpc-url=$RPC_URL --private-key=$PRIVATE_KEY --constructor-args <name> <symbol>

如果部署成功，您将看到部署钱包的地址、合约地址以及打印到您的终端的交易哈希。

从你的合约中铸造 NFT

使用 Foundry 用于与智能合约交互、发送交易和获取链数据的命令行工具 Cast 可以轻松调用 NFT 合约上的函数。让我们看看如何使用它从我们的 NFT 合约中铸造 NFT。

鉴于您已经在部署期间设置了 RPC 和私钥环境变量，请通过以下方式从您的合约中创建一个 NFT 跑步：

cast send --rpc-url=$RPC_URL <contractAddress> "mintTo(address)" <arg> --private-key=$PRIVATE_KEY

做得好！你刚刚从你的合约中铸造了你的第一个 NFT。您可以通过运行以下 cast call 命令来检查 currentTokenId 等于 1 的 NFT 的所有者。您在上面提供的地址应该作为所有者返回。

cast call --rpc-url=$RPC_URL --private-key=$PRIVATE_KEY <contractAddress> "ownerOf(uint256)" 1

扩展我们的 NFT 合约功能和测试

让我们通过添加元数据来表示 NFT 的内容来扩展我们的 NFT，并设置铸币价格、最大供应量以及从铸币中提取所收集收益的可能性。您可以使用以下代码片段替换当前的 NFT 合约：

// 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();

contract NFT is ERC721, Ownable {

    using Strings for uint256;
    string public baseURI;
    uint256 public currentTokenId;
    uint256 public constant TOTAL_SUPPLY = 10_000;
    uint256 public constant MINT_PRICE = 0.08 ether;

    constructor(
        string memory _name,
        string memory _symbol,
        string memory _baseURI
    ) ERC721(_name, _symbol) {
        baseURI = _baseURI;
    }

    function mintTo(address recipient) public payable returns (uint256) {
        if (msg.value != MINT_PRICE) {
            revert MintPriceNotPaid();
        }
        uint256 newTokenId = ++currentTokenId;
        if (newTokenId > TOTAL_SUPPLY) {
            revert MaxSupply();
        }
        _safeMint(recipient, newTokenId);
        return newTokenId;
    }

    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        if (ownerOf(tokenId) == address(0)) {
            revert NonExistentTokenURI();
        }
        return
            bytes(baseURI).length > 0
                ? string(abi.encodePacked(baseURI, tokenId.toString()))
                : "";
    }

    function withdrawPayments(address payable payee) external onlyOwner {
        uint256 balance = address(this).balance;
        (bool transferTx, ) = payee.call{value: balance}("");
        if (!transferTx) {
            revert WithdrawTransfer();
        }
    }
}

除此之外，我们还添加了元数据，可以通过调用 NFT 合约上的“tokenURI”方法从任何前端应用程序（如 OpenSea）查询这些元数据。

注意：如果您想在部署时向构造函数提供真实 URL，并托管此 NFT 合约的元数据，请按照[此处](https://docs.opensea.io/docs/ 第 3 部分-添加元数据和付款到您的合同#intro-to-nft-metadata）。

让我们测试一些添加的功能，以确保它按预期工作。 Foundry 通过 Forge 提供了一个极快的 EVM 原生测试框架。

在您的测试文件夹中，将当前的Contract.t.sol测试文件重命名为 NFT.t.sol。该文件将包含有关 NFT 的 mintTo 方法的所有测试。接下来，将现有的样板代码替换为以下代码：

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

import "forge-std/Test.sol";
import "../src/NFT.sol";

contract NFTTest is Test {
    using stdStorage for StdStorage;

    NFT private nft;

    function setUp() public {
        // Deploy NFT contract
        nft = new NFT("NFT_tutorial", "TUT", "baseUri");
    }

    function testFailNoMintPricePaid() public {
        nft.mintTo(address(1));
    }

    function testMintPricePaid() public {
        nft.mintTo{value: 0.08 ether}(address(1));
    }

    function testFailMaxSupplyReached() public {
        uint256 slot = stdstore
            .target(address(nft))
            .sig("currentTokenId()")
            .find();
        bytes32 loc = bytes32(slot);
        bytes32 mockedCurrentTokenId = bytes32(abi.encode(10000));
        vm.store(address(nft), loc, mockedCurrentTokenId);
        nft.mintTo{value: 0.08 ether}(address(1));
    }

    function testFailMintToZeroAddress() public {
        nft.mintTo{value: 0.08 ether}(address(0));
    }

    function testNewMintOwnerRegistered() public {
        nft.mintTo{value: 0.08 ether}(address(1));
        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));
    }

    function testBalanceIncremented() public {
        nft.mintTo{value: 0.08 ether}(address(1));
        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));
        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));
        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));
    }

    function testWithdrawalWorksAsOwner() public {
        // Mint an NFT, sending eth to the contract
        Receiver receiver = new Receiver();
        address payable payee = payable(address(0x1337));
        uint256 priorPayeeBalance = payee.balance;
        nft.mintTo{value: nft.MINT_PRICE()}(address(receiver));
        // Check that the balance of the contract is correct
        assertEq(address(nft).balance, nft.MINT_PRICE());
        uint256 nftBalance = address(nft).balance;
        // Withdraw the balance and assert it was transferred
        nft.withdrawPayments(payee);
        assertEq(payee.balance, priorPayeeBalance + nftBalance);
    }

    function testWithdrawalFailsAsNotOwner() public {
        // Mint an NFT, sending eth to the contract
        Receiver receiver = new Receiver();
        nft.mintTo{value: nft.MINT_PRICE()}(address(receiver));
        // Check that the balance of the contract is correct
        assertEq(address(nft).balance, nft.MINT_PRICE());
        // Confirm that a non-owner cannot withdraw
        vm.expectRevert("Ownable: caller is not the owner");
        vm.startPrank(address(0xd3ad));
        nft.withdrawPayments(payable(address(0xd3ad)));
        vm.stopPrank();
    }
}

contract Receiver is ERC721TokenReceiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 id,
        bytes calldata data
    ) external override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}

测试套件设置为带有setUp方法的合同，该方法在每个单独的测试之前运行。

如您所见，Forge 提供了许多 cheatcodes 来操纵状态以适应您的测试场景。

例如，我们的 testFailMaxSupplyReached 测试会检查在达到 NFT 的最大供应量时尝试铸造是否失败。因此，NFT 合约的 currentTokenId 需要通过使用商店作弊码设置为最大供应量，这允许您将数据写入您的合约存储槽。您希望写入的存储槽可以使用 forge-std 帮助程序库。您可以使用以下命令运行测试：

forge test

如果您想练习您的 Forge 技能，请为我们的 NFT 合约的其余方法编写测试。欢迎将它们 PR 到 nft-tutorial，您将在其中找到本教程的完整实现。

函数调用的gas报告

Foundry 提供有关您的合同的综合gas报告。对于测试中调用的每个函数，它都会返回最小、平均、中值和最大 gas 成本。要打印gas报告，只需运行：

forge test --gas-report

在查看合约中的各种 gas 优化时，这会派上用场。

让我们来看看我们通过用 Solmate 代替 OpenZeppelin 来实现我们的 ERC721 实现而节省的 gas。您可以在此处找到使用这两个库的 NFT 实现。以下是在该存储库上运行 forge test --gas-report 时生成的gas报告。

如您所见，我们使用 Solmate 的实施在一次成功的铸造中节省了大约 500 gas（mintTo 函数调用的最大 gas 成本）。

Gas report solmate NFT

Gas report OZ NFT

就是这样，我希望这能为您提供如何开始使用 Foundry 的良好实践基础。我们认为没有比在 solidity 中编写测试更好的方式来深入理解 solidity。您还将体验到更少的 javascript 和 solidity 之间的上下文切换。编码愉快！

注意：按照 this 教程学习如何使用 solidity 脚本部署此处使用的 NFT 合约。

Foundry 中文