1. Remix IDE 测试
1.1. AdvancedStorage.test.js
const { expect } = require("chai");
const { ethers } = require("ethers");
describe("AdvancedStorage", function () {
it("Check vault manager", async function () {
// Make sure contract is compiled and artifacts are generated
const advancedStorageMetadata = JSON.parse(await remix.call('fileManager', 'getFile', 'artifacts/AdvancedStorage.json'))
const signer = (new ethers.providers.Web3Provider(web3Provider)).getSigner()
const signerAddress = await signer.getAddress();
let AdvancedStorage = new ethers.ContractFactory(advancedStorageMetadata.abi, advancedStorageMetadata.data.bytecode.object, signer);
let advancedStorage = await AdvancedStorage.deploy();
console.log('storage contract Address: ' + advancedStorage.address);
await advancedStorage.deployed();
expect((await advancedStorage.vaultManager()).toString()).to.equal(signerAddress);
});
it("Check set initial investment", async function () {
const advancedStorageMetadata = JSON.parse(await remix.call('fileManager', 'getFile', 'artifacts/AdvancedStorage.json'));
const customerIdentityCardMetadata = JSON.parse(await remix.call('fileManager', 'getFile', 'artifacts/CustomerIdentityCard.json'));
const provider = new ethers.providers.Web3Provider(web3Provider)
const signer = provider.getSigner();
const acc2 = await provider.getSigner(1).getAddress();
let AdvancedStorage = new ethers.ContractFactory(advancedStorageMetadata.abi, advancedStorageMetadata.data.bytecode.object, signer);
let advancedStorage = await AdvancedStorage.deploy();
console.log('storage contract Address: ' + advancedStorage.address);
await advancedStorage.deployed();
await advancedStorage.setInitialInvestmentVault(10, 5, acc2.toString());
const customerIdentityCardAddress = (await advancedStorage.retrieveInvestmentVault())[3];
const customerIdentityCard = new ethers.Contract(customerIdentityCardAddress, customerIdentityCardMetadata.abi, signer);
expect((await advancedStorage.retrieveInvestmentVault())[1].toNumber()).to.equal(5);
expect((await advancedStorage.retrieveInvestmentVault())[2]).to.equal(true);
expect(customerIdentityCardAddress).to.equal(customerIdentityCard.address);
});
it("Check customer information", async function() {
const advancedStorageMetadata = JSON.parse(await remix.call('fileManager', 'getFile', 'artifacts/AdvancedStorage.json'));
const customerIdentityCardMetadata = JSON.parse(await remix.call('fileManager', 'getFile', 'artifacts/CustomerIdentityCard.json'));
const provider = new ethers.providers.Web3Provider(web3Provider)
const signer = provider.getSigner();
const acc2 = await provider.getSigner(1).getAddress();
let AdvancedStorage = new ethers.ContractFactory(advancedStorageMetadata.abi, advancedStorageMetadata.data.bytecode.object, signer);
let advancedStorage = await AdvancedStorage.deploy();
console.log('storage contract Address: ' + advancedStorage.address);
await advancedStorage.deployed();
await advancedStorage.setInitialInvestmentVault(10, 5, acc2.toString());
const customerIdentityCardAddress = (await advancedStorage.retrieveInvestmentVault())[3];
const customerIdentityCard = new ethers.Contract(customerIdentityCardAddress, customerIdentityCardMetadata.abi, signer);
expect(await customerIdentityCard.customer()).to.equal(acc2);
});
});1.2. AdvancedStorage_test.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.9.0;
// This import is automatically injected by Remix
import "remix_tests.sol";
// This import is required to use custom transaction context
// Although it may fail compilation in 'Solidity Compiler' plugin
// But it will work fine in 'Solidity Unit Testing' plugin
import "remix_accounts.sol";
import {AdvancedStorage, CustomerIdentityCard} from "../AdvancedStorage.sol";
// File name has to end with '_test.sol', this file can contain more than one testSuite contracts
contract testSuite is AdvancedStorage {
AdvancedStorage advancedStorage;
address acc0;
address acc1;
/// 'beforeAll' runs before all other tests
/// More special functions are: 'beforeEach', 'beforeAll', 'afterEach' & 'afterAll'
function beforeAll() public {
// <instantiate contract>
advancedStorage = new AdvancedStorage();
acc0 = TestsAccounts.getAccount(0);
acc1 = TestsAccounts.getAccount(1);
}
function checkVaultManager() public returns (bool) {
return Assert.equal(this.vaultManager(), msg.sender, "Vault Manager is not correct");
}
function checkSettingInitialInvestment() public returns (bool, bool, bool) {
setInitialInvestmentVault(
10,
5,
acc1
);
return (
Assert.equal(retrieveInvestmentVault().investmentDuration, block.timestamp + 10 days, "Duration is not correct"),
Assert.equal(retrieveInvestmentVault().returnOnInvestment, 5, "Return on Investment is not correct"),
Assert.equal(retrieveInvestmentVault().initialized, true, "Initialization status is not correct")
);
}
/// #sender: account-1
function checkFailedSettingInitialInvestmentButWithUnautorizedAccount() public returns (bool) {
setInitialInvestmentVault(
10,
5,
acc1
);
return (Assert.ok(true, "True"));
}
function checkRetrieveCustomerInformation() public returns (bool) {
return Assert.equal(retrieveCustomerInformation(), acc1, "Customer information is wrong");
}
}
1.3. SimpleStorage_test.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.9.0;
// This import is automatically injected by Remix
import "remix_tests.sol";
// This import is required to use custom transaction context
// Although it may fail compilation in 'Solidity Compiler' plugin
// But it will work fine in 'Solidity Unit Testing' plugin
import "remix_accounts.sol";
import "../SimpleStorage.sol";
// File name has to end with '_test.sol', this file can contain more than one testSuite contracts
contract testSuite is SimpleStorage {
SimpleStorage simpleStorage;
address acc0;
/// 'beforeAll' runs before all other tests
/// More special functions are: 'beforeEach', 'beforeAll', 'afterEach' & 'afterAll'
function beforeAll() public {
// <instantiate contract>
simpleStorage = new SimpleStorage();
acc0 = TestsAccounts.getAccount(0);
}
function checkMaintainerName() public returns (bool) {
return Assert.equal(simpleStorage.maintainerName(), "zxstim", "Maintainer name is not correct");
}
function checkVersion() public returns (bool) {
return Assert.equal(simpleStorage.version(), 1, "Version is not 1");
}
function checkDonationAddress() public returns (bool) {
return Assert.equal(simpleStorage.donationAddress(), 0xe3d25540BA6CED36a0ED5ce899b99B5963f43d3F, "Donation address is not correct");
}
/// #sender: account-0
function checkStoredPerson() public returns (bool, bool, bool, bool, bool, bool) {
Person memory person = storePerson("victor",30,true,10,2);
return (
Assert.equal(person.name, "victor", "Name is not correct"),
Assert.equal(person.age, 30, "Age is not correct"),
Assert.equal(person.overEighteen, true, "overEighteen status is not correct"),
Assert.equal(person.uuid, msg.sender, "Address is not correct"),
Assert.equal(person.assetValue, 10e18, "Asset value is not correct"),
Assert.equal(person.debtValue, 2e18, "Debt value is not correct")
);
}
/// #sender: account-0
function checkRetrivePersonWithAddress() public returns (bool, bool, bool, bool, bool, bool) {
Assert.ok(msg.sender == acc0, "caller should be default account i.e. acc0");
storePerson("victor",30,true,10,2);
return (
Assert.equal(retrievePerson(msg.sender).name, "victor", "Name is not correct"),
Assert.equal(retrievePerson(msg.sender).age, 30, "Age is not correct"),
Assert.equal(retrievePerson(msg.sender).overEighteen, true, "overEighteen status is not correct"),
Assert.equal(retrievePerson(msg.sender).uuid, msg.sender, "Address is not correct"),
Assert.equal(retrievePerson(msg.sender).assetValue, 10e18, "Asset value is not correct"),
Assert.equal(retrievePerson(msg.sender).debtValue, 2e18, "Debt value is not correct")
);
}
}
2. 测试 Solidity 文件
对 Solidity 文件进行全面测试对于确保区块链项目的质量、可靠性和安全性至关重要。
主要原因如下:
- 错误检测:测试有助于识别并修复 Solidity 代码中的错误。代码错误可能导致意外行为甚至资产损失。测试能帮你尽早发现这些错误,并在其引发严重问题之前将其解决。
- 确保安全性:测试有助于发现 Solidity 代码中的安全漏洞。安全漏洞可能会使你的项目面临遭受黑客攻击的风险。测试可助你识别这些漏洞并采取措施进行修补。
- 提高可靠性:测试有助于提升区块链项目的可靠性。当用户得知你的项目经过了充分测试后,他们会对项目产生更多信任,从而更乐意使用它。
- 节省时间和资金:从长远来看,测试有助于节省时间和资金。越早修复错误,就能避免日后产生更严重、成本更高的隐患。
测试 Solidity 文件的方法有多种。一些常见的方法包括:
- 单元测试:一种测试代码各个独立单元的方法。
- 集成测试:一种测试不同代码单元协同工作情况的方法。
- 分叉测试:一种在模拟真实环境的生态中测试代码的方法。
- Staging 测试:一种在真实环境但非生产环境中测试代码的方法。选择合适的测试方法取决于你项目的具体需求。
以下是有效测试 Solidity 文件的一些建议:
- 编写易于理解和维护的测试代码。
- 综合使用多种不同的测试方法。
- 实现测试自动化。
- 考虑使用专门的测试工具。
如何进行测试?
Remix、Hardhat 或 Foundry 都提供了各自用于测试智能合约的选项。你可以参考以下深入的 Docs:
3. 关于 Solidity 合约的更多信息
3.1. 构造函数 (constructor)
Constructor 是在智能合约初始化时立即运行的函数
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
// Base contract X
contract X {
string public name;
constructor(string memory _name) {
name = _name;
}
}3.2. 状态变量可见性 (State variable visibility)
public- Public 变量类似于internal变量(允许当前合约和继承合约访问),但会自动创建一个getter 函数,以便外部合约也能对其进行访问。internal- 该变量只能由当前合约及继承合约访问。这也是状态变量的默认可见性。private- 该变量只能由当前合约访问。
注意:
这些internal以及private变量仅限制对其他合约的访问权限。变量的值对所有人依然是可见的。
3.3. 函数可见性
external-函数只能从外部调用。public-函数既可以被另一个函数中的合约调用,也可以从外部调用。internal-函数只能由现有的合约或继承的合约.private-函数只能由当前的合约.
3.4. Getter 函数
函数 用于调用 public 编译器自动创建的变量。也用于指代 函数 用于查询变量以进行查看。
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;
contract C {
uint public data = 42;
}
contract Caller {
C c = new C();
function f() public view returns (uint) {
return c.data();
}
}3.5. 常量与不可变状态变量
constant- 其值在编译时立即固定(写入合约字节码)的变量。immutable- 其值可以在构造函数.
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.21;
uint constant X = 32**22 + 8;
contract C {
string constant TEXT = "abc";
bytes32 constant MY_HASH = keccak256("abc");
uint immutable decimals = 18;
uint immutable maxBalance;
address immutable owner = msg.sender;
constructor(uint decimals_, address ref) {
if (decimals_ != 0)
// Immutables are only immutable when deployed.
// At construction time they can be assigned to any number of times.
decimals = decimals_;
// Assignments to immutables can even access the environment.
maxBalance = ref.balance;
}
function isBalanceTooHigh(address other) public view returns (bool) {
return other.balance > maxBalance;
}
}3.6. Pure 函数
函数 不读取或更改区块链的状态。或者用作计算 函数.
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.9.0;
contract C {
function f(uint a, uint b) public pure returns (uint) {
return a * (b + 42);
}
}3.7. Payable 函数与地址
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
contract Payable {
// Payable address can send Ether via transfer or send
address payable public owner;
// Payable constructor can receive Ether
constructor() payable {
owner = payable(msg.sender);
}
// Function to deposit Ether into this contract.
// Call this function along with some Ether.
// The balance of this contract will be automatically updated.
function deposit() public payable {}
// Call this function along with some Ether.
// The function will throw an error since this function is not payable.
function notPayable() public {}
// Function to withdraw all Ether from this contract.
function withdraw() public {
// get the amount of Ether stored in this contract
uint256 amount = address(this).balance;
// send all Ether to owner
(bool success,) = owner.call{value: amount}("");
require(success, "Failed to send Ether");
}
// Function to transfer Ether from this contract to address from input
function transfer(address payable _to, uint256 _amount) public {
// Note that "to" is declared as payable
(bool success,) = _to.call{value: _amount}("");
require(success, "Failed to send Ether");
}
}3.8. 接收以太币与 Fallback 函数
一个 合约 最多可以拥有一个 receive 函数,使用 receive() external payable { ... } 声明(不含 函数 关键字)。该 函数 必须没有 参数,不能 返回 返回任何内容,且必须具备 external 可见性以及 payable 状态可变性。它可以被 virtual,也可以被 override 并且可以拥有 修饰器.
调用的是哪个 function,是 fallback() 还是
receive()?
发送 Ether
|
msg.data 是否为空
/ \
是 否
/ \
receive() 是否存在? fallback()
/ \
是 否
/ \
receive() fallback()// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
contract Fallback {
event Log(string func, uint256 gas);
// Fallback function must be declared as external.
fallback() external payable {
// send / transfer (forwards 2300 gas to this fallback function)
// call (forwards all of the gas)
emit Log("fallback", gasleft());
}
// Receive is a variant of fallback that is triggered when msg.data is empty
receive() external payable {
emit Log("receive", gasleft());
}
// Helper function to check the balance of this contract
function getBalance() public view returns (uint256) {
return address(this).balance;
}
}
contract SendToFallback {
function transferToFallback(address payable _to) public payable {
_to.transfer(msg.value);
}
function callFallback(address payable _to) public payable {
(bool sent,) = _to.call{value: msg.value}("");
require(sent, "Failed to send Ether");
}
}3.9. 预言机
智能合约预言机是区块链与外部世界之间的桥梁。它为智能合约提供来自区块链外部的数据源,例如 API、市场数据、天气数据等。
以下是如何在智能合约中使用预言机的几个示例:
- 为去中心化市场(DeFi)提供价格数据:预言机能够为加密资产提供价格数据,从而允许交易者在去中心化交易所上进行交易。
- 激活保险合约:预言机可以提供有关保险事件的数据,例如事故或自然灾害,从而触发保险赔付。
- 流程自动化:预言机可用于实现账单支付或供应链管理等流程的自动化。
Klaytn 上的预言机列表:https://klaytn.foundation/ecosystem/?search=&cate=oracles-bridges&sort=abc
4. Foundry Fundme
4.1. Foundry 框架
事实上,Remix IDE 在功能方面有诸多限制,因此我们将使用 Foundry——一个用于开发、测试和部署智能合约的框架。
4.2. 安装
访问网站 GetFoundry.sh 并按照说明进行操作。
4.3. 快速入门
访问并按照 Foundry Book 中的说明初始化项目。
4.4. Fund Me 项目
本练习基于 Patrick Collins 的 Foundry FundMe 代码库,但已进行更新以适配 Klaytn 环境。
- 首先运行
forge init klaytn-fund-me - 然后我们将创建
FundMe.sol文件
// FundMe.sol
// SPDX-License-Identifier: MIT
// 1. Pragma
pragma solidity ^0.8.19;
// 2. Imports
// We import the orakl library so we can interact with oracle
import { IAggregator } from "@bisonai/orakl-contracts/src/v0.1/interfaces/IAggregator.sol";
// We import the PriceConverter library so we can calculate the KLAY value
import { PriceConverter } from "./PriceConverter.sol";
// 3. Interfaces, Libraries, Contracts
// Declaring error is not the Owner of the contract
error FundMe__NotOwner();
/**
* @title A sample Funding Contract
* @author Patrick Collins
* @notice This contract is for creating a sample funding contract
* @dev This implements price feeds as our library
*/
contract FundMe {
// Type Declarations
// The next line means
// use the PriceConverter library for variables with type uint256
using PriceConverter for uint256;
// State variables
// Declare a public constant MINIMUM_USD with value $5 but equal to peb so must multiply by 10^18
uint256 public constant MINIMUM_USD = 5 * 10 ** 18;
// Declare a private and immutable address with the name i_owner, i means immutable.
address private immutable i_owner;
// Declare a private array containing a list of people who fund ether with the name s_funders, s means storage.
address[] private s_funders;
// Declare a mapping between address and private uint256 linking the address with the fund amount.
mapping(address => uint256) private s_addressToAmountFunded;
// Declare contract AggregatorV3Interface private and assign it to the variable s_pricefeed, s means storage
IAggregator private s_priceFeed;
// Events (we have none!)
// Modifiers
// Declare an onlyOwner modifier to assign to a function that only the owner can call
modifier onlyOwner() {
// require(msg.sender == i_owner);
if (msg.sender != i_owner) revert FundMe__NotOwner();
_;
}
// Functions Order:
//// constructor
//// receive
//// fallback
//// external
//// public
//// internal
//// private
//// view / pure
// Declaring a constructor with an address for priceFeed implies that this is the address of the Oracle contract with IAggregator
constructor(address priceFeed) {
// Input the address into the interface and assign it to the variable s_priceFeed
s_priceFeed = IAggregator(priceFeed);
// Assign the variable i_owner to msg.sender (the person who deploys this contract)
i_owner = msg.sender;
}
/// @notice Funds our contract based on the KLAY/USDT price from Orakl
// Deposit to our contract based on ETH/USD price
function fund() public payable {
require(msg.value.getConversionRate(s_priceFeed) >= MINIMUM_USD, "You need to spend more ETH!");
// require(PriceConverter.getConversionRate(msg.value) >= MINIMUM_USD, "You need to spend more ETH!");
// Then map the sender's address with msg.value in mapping s_addressToAmountFunded
s_addressToAmountFunded[msg.sender] += msg.value;
// Then add the sender address to the list of funders
s_funders.push(msg.sender);
}
function withdraw() public onlyOwner {
// Use for loop, starting from index 0 to index less than the length of the list, and index plus 1 for each loop
for (uint256 funderIndex = 0; funderIndex < s_funders.length; funderIndex++) {
// assign the address value at funderIndex in the s_funders list to the funder address
address funder = s_funders[funderIndex];
// Change the value of mapping s_addressToAmountFunded whose address is funder to 0, meaning this funder has withdrawn
s_addressToAmountFunded[funder] = 0;
}
// Create a new s_funders list with a new dynamic array (literally a list) of size 0
s_funders = new address[](0);
// Transfer vs call vs Send
// Transfer vs call vs Send
// - transfer (2300 gas, throws error if any)
// - send (2300 gas, returns bool for success or failure)
// - call (forward all gas or set gas, returns bool for success or failure)
// payable(msg.sender).transfer(address(this).balance);
// Send the entire balance of this contract to i_owner with no data in the transaction and return boolean success or not
(bool success,) = i_owner.call{value: address(this).balance}("");
// Require bool success true otherwise revert completely
require(success);
}
function cheaperWithdraw() public onlyOwner {
// Copy the list of s_funders from storage to memory, that is, load from global state to local state. Changing global state consumes more gas than local state
address[] memory funders = s_funders;
// mappings can't be in memory, sorry!
for (uint256 funderIndex = 0; funderIndex < funders.length; funderIndex++) {
address funder = funders[funderIndex];
s_addressToAmountFunded[funder] = 0;
}
s_funders = new address[](0);
// payable(msg.sender).transfer(address(this).balance);
(bool success,) = i_owner.call{value: address(this).balance}("");
require(success);
}
/** Getter Functions */
// Functions are only used to GET information
/**
* @notice Gets the amount that an address has funded
* @param fundingAddress the address of the funder
* @return the amount funded
*/
function getAddressToAmountFunded(address fundingAddress) public view returns (uint256) {
return s_addressToAmountFunded[fundingAddress];
}
/**
* @notice Gets the funder at a specific index
* @param index the index of the funder
* @return the address of the funder
*/
function getFunder(uint256 index) public view returns (address) {
return s_funders[index];
}
/// @notice Gets the owner of the contract
function getOwner() public view returns (address) {
return i_owner;
}
/// @notice Gets the price feed
function getPriceFeed() public view returns (IAggregator) {
return s_priceFeed;
}
/// @notice Gets the decimals of the price feed
function getDecimals() public view returns (uint8) {
return s_priceFeed.decimals();
}
/// @notice Gets the description of the price feed
function getDescription() public view returns (string memory) {
return s_priceFeed.description();
}
}- 我们继续创建
PriceConverter.sol文件
// PriceConverter.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
// import IAggregator từ orakl repository
import { IAggregator } from "@bisonai/orakl-contracts/src/v0.1/interfaces/IAggregator.sol";
// Declare a library named PriceConverter
library PriceConverter {
// Declare function getPrice with input as contract interface and return uint256
function getPrice(IAggregator priceFeed) internal view returns (uint256) {
// gọi function latestRoundData() trong priceFeed
(, int256 answer,,,) = priceFeed.latestRoundData();
// Returns the ETH/USD rate with 18 digits (Oracle has 8 zeros so add 10 zeros)
// ETH/USD rate in 18 digit
return uint256(answer * 10000000000);
}
// 1000000000
// call it get fiatConversionRate, since it assumes something about decimals
// It wouldn't work for every aggregator
// Convert KLAY amount to USD amount
// function getConversionRate takes input ethAmount with type uint256 and interface contract, returns uint256
function getConversionRate(uint256 ethAmount, IAggregator priceFeed) internal view returns (uint256) {
// First get the eth price using getPrice and assign it to the variable ethPrice
uint256 ethPrice = getPrice(priceFeed);
// Then multiply ethPrice by the amount of ether and divide by 18 zeros
// In solidity, we should multiply before dividing because there is no float
// This calculation is ethPrice (18 digits) * ethAmount (18 digits) / 18 digits to get back 18 digits.
uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1000000000000000000;
// Returns the USD value of the ether amount
// the actual ETH/USD conversation rate, after adjusting the extra 0s.
return ethAmountInUsd;
}
}- 为了处理 Foundry 的导入依赖项
forge install Bisonai/oraklforge install Cyfrin/foundry-devops添加 重定向映射(remappings)和 rpc_endpoints 实现 foundry.toml 文件
[profile.default]
src = "src"
out = "out"
libs = ["lib"]
remappings = [
"@bisonai/orakl-contracts/src/=lib/orakl/contracts/src/",
]
ffi = true
fs_permissions = [{ access = "read", path = "./broadcast" }]
[rpc_endpoints]
baobab = "${BAOBAB_RPC_URL}"
# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options- 添加
.env文件并添加BAOBAB_RPC_URLBAOBAB_RPC_URL可从 Ankr、Allthatnodes 等平台获取
BAOBAB_RPC_URL=https://xxxxxx/xxxxx- 在
tests文件夹中,我们创建 3 个子文件夹unit,integration,mocks及相关文件FundMeTest.t.sol,interactionsTest.t.sol,MockDataFeedAggregator.sol
.
└── tests
├── integration
│ └── interactionsTest.t.sol
├── mocks
│ └── MockDataFeedAggregator.sol
└── unit
└── FundMeTest.t.sol复制这 3 个文件的内容
FundMeTest.t.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import { DeployFundMe } from "../../script/DeployFundMe.s.sol";
import { FundMe } from "../../src/FundMe.sol";
import { HelperConfig } from "../../script/HelperConfig.s.sol";
import { Test, console } from "forge-std/Test.sol";
import { StdCheats } from "forge-std/StdCheats.sol";
contract FundMeTest is StdCheats, Test {
FundMe public fundMe;
HelperConfig public helperConfig;
uint256 public constant SEND_VALUE = 0.1 ether; // just a value to make sure we are sending enough!
uint256 public constant STARTING_USER_BALANCE = 10 ether;
uint256 public constant GAS_PRICE = 1;
address public constant USER = address(1);
// uint256 public constant SEND_VALUE = 1e18;
// uint256 public constant SEND_VALUE = 1_000_000_000_000_000_000;
// uint256 public constant SEND_VALUE = 1000000000000000000;
function setUp() external {
DeployFundMe deployer = new DeployFundMe();
(fundMe, helperConfig) = deployer.run();
vm.deal(USER, STARTING_USER_BALANCE);
}
function testPriceFeedSetCorrectly() public view {
address retreivedPriceFeed = address(fundMe.getPriceFeed());
(address expectedPriceFeed) = helperConfig.activeNetworkConfig();
assertEq(retreivedPriceFeed, expectedPriceFeed);
}
function testFundFailsWithoutEnoughETH() public {
vm.expectRevert();
fundMe.fund();
}
function testFundUpdatesFundedDataStructure() public {
vm.startPrank(USER);
fundMe.fund{value: SEND_VALUE}();
vm.stopPrank();
uint256 amountFunded = fundMe.getAddressToAmountFunded(USER);
assertEq(amountFunded, SEND_VALUE);
}
function testAddsFunderToArrayOfFunders() public {
vm.startPrank(USER);
fundMe.fund{value: SEND_VALUE}();
vm.stopPrank();
address funder = fundMe.getFunder(0);
assertEq(funder, USER);
}
// https://twitter.com/PaulRBerg/status/1624763320539525121
modifier funded() {
vm.prank(USER);
fundMe.fund{value: SEND_VALUE}();
assert(address(fundMe).balance > 0);
_;
}
function testOnlyOwnerCanWithdraw() public funded {
vm.expectRevert();
fundMe.withdraw();
}
function testWithdrawFromASingleFunder() public funded {
// Arrange
uint256 startingFundMeBalance = address(fundMe).balance;
uint256 startingOwnerBalance = fundMe.getOwner().balance;
// vm.txGasPrice(GAS_PRICE);
// uint256 gasStart = gasleft();
// // Act
vm.startPrank(fundMe.getOwner());
fundMe.withdraw();
vm.stopPrank();
// uint256 gasEnd = gasleft();
// uint256 gasUsed = (gasStart - gasEnd) * tx.gasprice;
// Assert
uint256 endingFundMeBalance = address(fundMe).balance;
uint256 endingOwnerBalance = fundMe.getOwner().balance;
assertEq(endingFundMeBalance, 0);
assertEq(
startingFundMeBalance + startingOwnerBalance,
endingOwnerBalance // + gasUsed
);
}
// Can we do our withdraw function a cheaper way?
function testWithdrawFromMultipleFunders() public funded {
uint160 numberOfFunders = 10;
uint160 startingFunderIndex = 2;
for (uint160 i = startingFunderIndex; i < numberOfFunders + startingFunderIndex; i++) {
// we get hoax from stdcheats
// prank + deal
hoax(address(i), STARTING_USER_BALANCE);
fundMe.fund{value: SEND_VALUE}();
}
uint256 startingFundMeBalance = address(fundMe).balance;
uint256 startingOwnerBalance = fundMe.getOwner().balance;
vm.startPrank(fundMe.getOwner());
fundMe.withdraw();
vm.stopPrank();
assert(address(fundMe).balance == 0);
assert(startingFundMeBalance + startingOwnerBalance == fundMe.getOwner().balance);
assert((numberOfFunders + 1) * SEND_VALUE == fundMe.getOwner().balance - startingOwnerBalance);
}
}MockDataFeedAggregator.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @title MockV3Aggregator
* @notice Based on the FluxAggregator contract
* @notice Use this contract when you need to test
* other contract's ability to read data from an
* aggregator contract, but how the aggregator got
* its answer is unimportant
*/
contract MockDataFeedAggregator {
uint256 public constant version = 4;
uint8 public decimals;
int256 public latestAnswer;
uint256 public latestTimestamp;
uint256 public latestRound;
mapping(uint256 => int256) public getAnswer;
mapping(uint256 => uint256) public getTimestamp;
mapping(uint256 => uint256) private getStartedAt;
constructor(uint8 _decimals, int256 _initialAnswer) {
decimals = _decimals;
updateAnswer(_initialAnswer);
}
function updateAnswer(int256 _answer) public {
latestAnswer = _answer;
latestTimestamp = block.timestamp;
latestRound++;
getAnswer[latestRound] = _answer;
getTimestamp[latestRound] = block.timestamp;
getStartedAt[latestRound] = block.timestamp;
}
function updateRoundData(uint80 _roundId, int256 _answer, uint256 _timestamp, uint256 _startedAt) public {
latestRound = _roundId;
latestAnswer = _answer;
latestTimestamp = _timestamp;
getAnswer[latestRound] = _answer;
getTimestamp[latestRound] = _timestamp;
getStartedAt[latestRound] = _startedAt;
}
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
{
return (_roundId, getAnswer[_roundId], getStartedAt[_roundId], getTimestamp[_roundId], _roundId);
}
function latestRoundData()
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
{
return (
uint80(latestRound),
getAnswer[latestRound],
getStartedAt[latestRound],
getTimestamp[latestRound],
uint80(latestRound)
);
}
function description() external pure returns (string memory) {
return "v0.6/test/mock/MockV3Aggregator.sol";
}
}interactionsTest.t.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import { DeployFundMe } from "../../script/DeployFundMe.s.sol";
import { FundFundMe, WithdrawFundMe } from "../../script/Interactions.s.sol";
import { FundMe } from "../../src/FundMe.sol";
import { HelperConfig } from "../../script/HelperConfig.s.sol";
import { Test, console } from "forge-std/Test.sol";
import { StdCheats } from "forge-std/StdCheats.sol";
contract InteractionsTest is StdCheats, Test {
FundMe public fundMe;
HelperConfig public helperConfig;
uint256 public constant SEND_VALUE = 0.1 ether; // just a value to make sure we are sending enough!
uint256 public constant STARTING_USER_BALANCE = 10 ether;
uint256 public constant GAS_PRICE = 1;
address public constant USER = address(1);
// uint256 public constant SEND_VALUE = 1e18;
// uint256 public constant SEND_VALUE = 1_000_000_000_000_000_000;
// uint256 public constant SEND_VALUE = 1000000000000000000;
function setUp() external {
DeployFundMe deployer = new DeployFundMe();
(fundMe, helperConfig) = deployer.run();
vm.deal(USER, STARTING_USER_BALANCE);
}
function testUserCanFundAndOwnerWithdraw() public {
FundFundMe fundFundMe = new FundFundMe();
fundFundMe.fundFundMe(address(fundMe));
WithdrawFundMe withdrawFundMe = new WithdrawFundMe();
withdrawFundMe.withdrawFundMe(address(fundMe));
assert(address(fundMe).balance == 0);
}
}- 然后进入
scripts文件夹并创建以下文件DeployFundMe.s.sol,HelperConfig.s.sol以及Interactions.s.sol
.
└── script
├── DeployFundMe.s.sol
├── HelperConfig.s.sol
└── Interactions.s.solDeployFundMe.s.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;
import { Script } from "forge-std/Script.sol";
import { HelperConfig } from "./HelperConfig.s.sol";
import { FundMe } from "../src/FundMe.sol";
contract DeployFundMe is Script {
function run() external returns (FundMe, HelperConfig) {
HelperConfig helperConfig = new HelperConfig(); // This comes with our mocks!
address priceFeed = helperConfig.activeNetworkConfig();
vm.startBroadcast();
FundMe fundMe = new FundMe(priceFeed);
vm.stopBroadcast();
return (fundMe, helperConfig);
}
}HelperConfig.s.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { MockDataFeedAggregator } from "../test/mocks/MockDataFeedAggregator.sol";
import { Script } from "forge-std/Script.sol";
contract HelperConfig is Script {
NetworkConfig public activeNetworkConfig;
uint8 public constant DECIMALS = 8;
int256 public constant INITIAL_PRICE = 2000e8;
struct NetworkConfig {
address priceFeed;
}
event HelperConfig__CreatedMockPriceFeed(address priceFeed);
constructor() {
if (block.chainid == 1001) {
activeNetworkConfig = getBaobabKlayConfig();
} else {
activeNetworkConfig = getOrCreateAnvilBaobabConfig();
}
}
function getBaobabKlayConfig() public pure returns (NetworkConfig memory baobabNetworkConfig) {
baobabNetworkConfig = NetworkConfig({
priceFeed: 0x33D6ee12D4ADE244100F09b280e159659fe0ACE0 // KLAY / USDT
});
}
function getOrCreateAnvilBaobabConfig() public returns (NetworkConfig memory anvilNetworkConfig) {
// Check to see if we set an active network config
if (activeNetworkConfig.priceFeed != address(0)) {
return activeNetworkConfig;
}
vm.startBroadcast();
MockDataFeedAggregator mockPriceFeed = new MockDataFeedAggregator(
DECIMALS,
INITIAL_PRICE
);
vm.stopBroadcast();
emit HelperConfig__CreatedMockPriceFeed(address(mockPriceFeed));
anvilNetworkConfig = NetworkConfig({priceFeed: address(mockPriceFeed)});
}
}Interactions.s.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;
import { Script, console } from "forge-std/Script.sol";
import { FundMe } from "../src/FundMe.sol";
import { DevOpsTools } from "foundry-devops/src/DevOpsTools.sol";
contract FundFundMe is Script {
uint256 SEND_VALUE = 0.1 ether;
function fundFundMe(address mostRecentlyDeployed) public {
vm.startBroadcast();
FundMe(payable(mostRecentlyDeployed)).fund{value: SEND_VALUE}();
vm.stopBroadcast();
console.log("Funded FundMe with %s", SEND_VALUE);
}
function run() external {
address mostRecentlyDeployed = DevOpsTools.get_most_recent_deployment("FundMe", block.chainid);
fundFundMe(mostRecentlyDeployed);
}
}
contract WithdrawFundMe is Script {
function withdrawFundMe(address mostRecentlyDeployed) public {
vm.startBroadcast();
FundMe(payable(mostRecentlyDeployed)).withdraw();
vm.stopBroadcast();
console.log("Withdraw FundMe balance!");
}
function run() external {
address mostRecentlyDeployed = DevOpsTools.get_most_recent_deployment("FundMe", block.chainid);
withdrawFundMe(mostRecentlyDeployed);
}
}- 部署:使用以下命令部署至 Baobab 测试网
forge script script/DeployFundMe.s.sol --rpc-url $BAOBAB_RPC_URL --account $WALLET_NAME --sender $SENDER_ADDRESS --broadcast --gas-estimate-multiplier 200--gas-estimate-multiplier 200- 用于将预估 Gas 乘以 2,以防因 Gas 不足而导致交易失败--sender $SENDER_ADDRESS- 替换为$SENDER_ADDRESS您的地址--account $WALLET_NAME- 您可以使用以下命令进行设置cast wallet new以及cast wallet import。替换$WALLET_NAME为您保存的密钥库名称
5. Hardhat Fundme
Hardhat 框架
5.1. 设置开发环境
mkdir hardhat-fundme
cd hardhat-fundme为了使用 Hardhat,我们需要设置开发环境并安装 Hardhat。请按照以下步骤操作:
步骤 1:创建项目目录
步骤 2:初始化 npm 项目
在终端中粘贴此命令以创建 package.json 文件
npm init -y步骤 3:安装 Hardhat 及其他依赖
- 在终端中粘贴以下代码以安装 Hardhat
npm install --save-dev hardhat- 粘贴以下代码以安装其他依赖
npm install dotenv @bisonai/orakl-contracts步骤 4:初始化 Hardhat 项目
npx hardhat init请务必按照终端中高亮显示的提示进行操作。对于本项目,我们选择了 hardhat javascript 项目 并安装了 hardhat-toolbox。
初始化 Hardhat 项目后,当前目录应包含:
1. contracts/ – 该文件夹包含智能合约代码。
2. ignition/ – 该文件夹包含用于在区块链网络上部署合约的代码。
3. test/ – 该文件夹包含用于测试智能合约的所有单元测试。
4. hardhat.config.js – 该文件包含对 Hardhat 运行、FundMe 合约部署与验证至关重要的配置文件。步骤 5:创建 .env 文件
现在在项目文件夹中创建您的 .env 文件。该文件可帮助我们将环境变量从 .env 文件加载到 process.env.
- 在终端中粘贴此命令以创建 .env 文件
touch .env- 创建文件后,让我们将 .env 文件配置为如下所示。Kairos RPC URL 可以在此处找到:
KAIA_KAIROS_URL= "您的 Kairos RPC 链接"
PRIVATE_KEY= "从 MetaMask 钱包中复制的私钥"步骤 6:设置 Hardhat 配置
修改您的 hardhat.config.js 并使用以下配置:
require("@nomicfoundation/hardhat-toolbox");
require('dotenv').config()
module.exports = {
solidity: "0.8.24",
networks: {
kairos: {
url: process.env.KAIA_KAIROS_URL || "",
gasPrice: 250000000000,
accounts:
process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
}
},
etherscan: {
apiKey: {
kairos: "unnecessary",
},
customChains: [
{
network: "kairos",
chainId: 1001,
urls: {
apiURL: "https://api-baobab.klaytnscope.com/api",
browserURL: "https://baobab.klaytnscope.com",
},
},
]
}
};
现在开发环境已经搭建完毕,让我们开始编写 Fundme 智能合约。
5.2. 创建 FundMe 智能合约
在 contracts 文件夹中,您将创建 FundMe.sol 以及 PriceConverter.sol 分别创建文件。
FundMe.sol
// FundMe.sol
// SPDX-License-Identifier: MIT
// 1. Pragma
pragma solidity ^0.8.19;
// 2. Imports
// We import the orakl library so we can interact with oracle
import { IFeedProxy } from "@bisonai/orakl-contracts/v0.2/src/interfaces/IFeedProxy.sol";
// We import the PriceConverter library so we can calculate the KLAY value
import { PriceConverter } from "./PriceConverter.sol";
// 3. Interfaces, Libraries, Contracts
// Declaring error is not the Owner of the contract
error FundMe__NotOwner();
/**
* @title A sample Funding Contract
* @author Patrick Collins
* @notice This contract is for creating a sample funding contract
* @dev This implements price feeds as our library
*/
contract FundMe {
// Type Declarations
// The next line means
// use the PriceConverter library for variables with type uint256
using PriceConverter for uint256;
// State variables
// Declare a public constant MINIMUM_USD with value $5 but equal to peb so must multiply by 10^18
uint256 public constant MINIMUM_USD = 5 * 10 ** 18;
// Declare a private and immutable address with the name i_owner, i means immutable.
address private immutable i_owner;
// Declare a private array containing a list of people who fund ether with the name s_funders, s means storage.
address[] private s_funders;
// Declare a mapping between address and private uint256 linking the address with the fund amount.
mapping(address => uint256) private s_addressToAmountFunded;
// Declare contract AggregatorV2Interface internal and assign it to the variable s_dataFeed, s means storage
IFeedProxy internal s_dataFeed;
// Events (we have none!)
// Modifiers
// Declare an onlyOwner modifier to assign to a function that only the owner can call
modifier onlyOwner() {
// require(msg.sender == i_owner);
if (msg.sender != i_owner) revert FundMe__NotOwner();
_;
}
// Functions Order:
//// constructor
//// receive
//// fallback
//// external
//// public
//// internal
//// private
//// view / pure
// Declaring a constructor with an address for priceFeed implies that this is the address of the Oracle contract with IAggregator
constructor(address feedProxy) {
// Input the address into the interface and assign it to the variable s_priceFeed
// s_priceFeed = IAggregator(priceFeed);
s_dataFeed = IFeedProxy(feedProxy);
// Assign the variable i_owner to msg.sender (the person who deploys this contract)
i_owner = msg.sender;
}
/// @notice Funds our contract based on the KLAY/USDT price from Orakl
// Deposit to our contract based on ETH/USD price
function fund() public payable {
require(msg.value.getConversionRate(s_dataFeed) >= MINIMUM_USD, "You need to spend more ETH!");
// require(PriceConverter.getConversionRate(msg.value) >= MINIMUM_USD, "You need to spend more ETH!");
// Then map the sender's address with msg.value in mapping s_addressToAmountFunded
s_addressToAmountFunded[msg.sender] += msg.value;
// Then add the sender address to the list of funders
s_funders.push(msg.sender);
}
function withdraw() public onlyOwner {
// Use for loop, starting from index 0 to index less than the length of the list, and index plus 1 for each loop
for (uint256 funderIndex = 0; funderIndex < s_funders.length; funderIndex++) {
// assign the address value at funderIndex in the s_funders list to the funder address
address funder = s_funders[funderIndex];
// Change the value of mapping s_addressToAmountFunded whose address is funder to 0, meaning this funder has withdrawn
s_addressToAmountFunded[funder] = 0;
}
// Create a new s_funders list with a new dynamic array (literally a list) of size 0
s_funders = new address[](0);
// Transfer vs call vs Send
// Transfer vs call vs Send
// - transfer (2300 gas, throws error if any)
// - send (2300 gas, returns bool for success or failure)
// - call (forward all gas or set gas, returns bool for success or failure)
// payable(msg.sender).transfer(address(this).balance);
// Send the entire balance of this contract to i_owner with no data in the transaction and return boolean success or not
(bool success,) = i_owner.call{value: address(this).balance}("");
// Require bool success true otherwise revert completely
require(success);
}
function cheaperWithdraw() public onlyOwner {
// Copy the list of s_funders from storage to memory, that is, load from global state to local state. Changing global state consumes more gas than local state
address[] memory funders = s_funders;
// mappings can't be in memory, sorry!
for (uint256 funderIndex = 0; funderIndex < funders.length; funderIndex++) {
address funder = funders[funderIndex];
s_addressToAmountFunded[funder] = 0;
}
s_funders = new address[](0);
// payable(msg.sender).transfer(address(this).balance);
(bool success,) = i_owner.call{value: address(this).balance}("");
require(success);
}
/** Getter Functions */
// Functions are only used to GET information
/**
* @notice Gets the amount that an address has funded
* @param fundingAddress the address of the funder
* @return the amount funded
*/
function getAddressToAmountFunded(address fundingAddress) public view returns (uint256) {
return s_addressToAmountFunded[fundingAddress];
}
/**
* @notice Gets the funder at a specific index
* @param index the index of the funder
* @return the address of the funder
*/
function getFunder(uint256 index) public view returns (address) {
return s_funders[index];
}
/// @notice Gets the owner of the contract
function getOwner() public view returns (address) {
return i_owner;
}
/// @notice Gets the price feed
function getPriceFeed() public view returns (address) {
return s_dataFeed.getFeed();
}
/// @notice Gets the decimals of the price feed
function getDecimals() public view returns (uint8) {
return s_dataFeed.decimals();
}
}PriceConverter.sol
// PriceConverter.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
// import IAggregator từ orakl repository
import { IFeedProxy } from "@bisonai/orakl-contracts/v0.2/src/interfaces/IFeedProxy.sol";
// Declare a library named PriceConverter
library PriceConverter {
// Declare function getPrice with input as contract interface and return uint256
function getPrice(IFeedProxy dataFeed) internal view returns (uint256) {
// gọi function latestRoundData() trong priceFeed
(, int256 answer,) = dataFeed.latestRoundData();
// Returns the ETH/USD rate with 18 digits (Oracle has 8 zeros so add 10 zeros)
// ETH/USD rate in 18 digit
return uint256(answer * 10000000000);
}
// 1000000000
// call it get fiatConversionRate, since it assumes something about decimals
// It wouldn't work for every aggregator
// Convert KLAY amount to USD amount
// function getConversionRate takes input ethAmount with type uint256 and interface contract, returns uint256
function getConversionRate(uint256 ethAmount, IFeedProxy dataFeed) internal view returns (uint256) {
// First get the eth price using getPrice and assign it to the variable ethPrice
uint256 ethPrice = getPrice(dataFeed);
// Then multiply ethPrice by the amount of ether and divide by 18 zeros
// In solidity, we should multiply before dividing because there is no float
// This calculation is ethPrice (18 digits) * ethAmount (18 digits) / 18 digits to get back 18 digits.
uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1000000000000000000;
// Returns the USD value of the ether amount
// the actual ETH/USD conversation rate, after adjusting the extra 0s.
return ethAmountInUsd;
}
}5.3 测试 FundMe 智能合约
第 1 步: 在“资源管理器”窗格中,选中 test 文件夹,然后点击“新建文件”按钮来创建一个名为以下名称的新文件: Fundme.js
第 2 步: 创建一个 MockDataFeedAggregator.sol 在 contracts 文件夹中用于测试。将以下代码复制并粘贴到该文件中:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @title MockV3Aggregator
* @notice Based on the FluxAggregator contract
* @notice Use this contract when you need to test
* other contract's ability to read data from an
* aggregator contract, but how the aggregator got
* its answer is unimportant
*/
contract MockDataFeedAggregator {
uint256 public constant version = 4;
uint8 public decimals;
int256 public latestAnswer;
uint256 public latestTimestamp;
uint256 public latestRound;
mapping(uint256 => int256) public getAnswer;
mapping(uint256 => uint256) public getTimestamp;
mapping(uint256 => uint256) private getStartedAt;
constructor(uint8 _decimals, int256 _initialAnswer) {
decimals = _decimals;
updateAnswer(_initialAnswer);
}
function updateAnswer(int256 _answer) public {
latestAnswer = _answer;
latestTimestamp = block.timestamp;
latestRound++;
getAnswer[latestRound] = _answer;
getTimestamp[latestRound] = block.timestamp;
getStartedAt[latestRound] = block.timestamp;
}
function updateRoundData(uint80 _roundId, int256 _answer, uint256 _timestamp, uint256 _startedAt) public {
latestRound = _roundId;
latestAnswer = _answer;
latestTimestamp = _timestamp;
getAnswer[latestRound] = _answer;
getTimestamp[latestRound] = _timestamp;
getStartedAt[latestRound] = _startedAt;
}
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
{
return (_roundId, getAnswer[_roundId], getStartedAt[_roundId], getTimestamp[_roundId], _roundId);
}
function latestRoundData()
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
{
return (
uint80(latestRound),
getAnswer[latestRound],
getStartedAt[latestRound],
getTimestamp[latestRound],
uint80(latestRound)
);
}
function description() external pure returns (string memory) {
return "v0.6/test/mock/MockV3Aggregator.sol";
}
}第 3 步:将以下代码复制并粘贴到 Fundme.js 文件中:
// Fundme.js
const { expect } = require("chai");
const { ethers } = require("hardhat");
const { loadFixture } = require("@nomicfoundation/hardhat-toolbox/network-helpers");
describe("FundMe", function () {
async function deployContractsFixture() {
const [deployer, addr1, addr2] = await ethers.getSigners();
const MockDataFeedAggregator = await ethers.getContractFactory("MockDataFeedAggregator");
const mockPriceFeed = await MockDataFeedAggregator.connect(deployer).deploy(8, 2000 * 10 ** 8); // Example price of 2000 USD with 8 decimals
await mockPriceFeed.waitForDeployment(); // Ensure the contract is deployed
// Use fully qualified name for FundMe contract
const FundMe = await ethers.getContractFactory("contracts/FundMe.sol:FundMe");
const fundMe = await FundMe.connect(deployer).deploy(mockPriceFeed.target);
await fundMe.waitForDeployment(); // Ensure the contract is deployed
return { fundMe, mockPriceFeed, deployer, addr1, addr2 };
}
describe("Deployment", function () {
it("Should set the right owner", async function () {
const { fundMe, deployer } = await loadFixture(deployContractsFixture);
expect(await fundMe.getOwner()).to.equal(deployer.address);
});
});
describe("Fund", function () {
it("Should accept funds", async function () {
const { fundMe, addr1 } = await loadFixture(deployContractsFixture);
const sendValue = ethers.parseEther("1"); // 1 ETH
await fundMe.connect(addr1).fund({ value: sendValue });
expect(await fundMe.getAddressToAmountFunded(addr1.address)).to.equal(sendValue);
});
it("Should require a minimum amount in USD", async function () {
const { fundMe, addr1 } = await loadFixture(deployContractsFixture);
const sendValue = ethers.parseEther("0.001"); // 0.001 ETH, less than minimum
await expect(fundMe.connect(addr1).fund({ value: sendValue })).to.be.revertedWith(
"You need to spend more ETH!"
);
});
});
describe("Withdraw", function () {
it("Should withdraw ETH correctly", async function () {
const { fundMe, addr1 } = await loadFixture(deployContractsFixture);
const sendValue = ethers.parseEther("1"); // 1 ETH
await fundMe.connect(addr1).fund({ value: sendValue });
await fundMe.withdraw();
expect(await ethers.provider.getBalance(fundMe.target)).to.equal(0);
});
it("Should only allow the owner to withdraw", async function () {
const { fundMe, addr1 } = await loadFixture(deployContractsFixture);
const sendValue = ethers.parseEther("1"); // 1 ETH
await fundMe.connect(addr1).fund({ value: sendValue });
await expect(fundMe.connect(addr1).withdraw()).to.be.revertedWithCustomError(
fundMe,
"FundMe__NotOwner"
);
});
});
});
第 4 步:要运行测试,请打开终端并执行以下命令:
5.4 部署智能合约
第 1 步:在“资源管理器”窗格中,选中 Ignition/modules 文件夹,然后点击“新建文件”按钮来创建一个名为以下名称的新文件: Fundme.js
第 2 步:将以下代码复制并粘贴到文件中。
const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules");
const PRICE_FEED_ADDRESS = "0x1408cb13d84ba8cb533fdf332db5d78290b071c9";
module.exports = buildModule("FundMeModule", (m) => {
const priceFeedAddr = m.getParameter("_priceFeed", PRICE_FEED_ADDRESS);
const fundMe = m.contract("FundMe", [priceFeedAddr], {});
return { fundMe };
});步骤 3:在终端中运行以下命令,指示 Hardhat 将您的 Fundme 合约部署到 Kaia 测试网(Kairos)
npx hardhat ignition deploy ignition/modules/Fundme.js --network kairos5.5 验证智能合约
在终端中复制并粘贴以下代码:
// example
// npx hardhat verify –network <network> <deployed_address> <parameters>
npx hardhat verify --network kairos 0xa9a6f38b67d7ba2b716d0d2bd21974e2149df7ef 0xf0d6Ccdd18B8A7108b901af872021109C27095bA