以太坊区块链私有链相关操作

最新推荐文章于 2023-10-24 12:23:35 发布

难、起名

最新推荐文章于 2023-10-24 12:23:35 发布

阅读量435

点赞数

文章标签：区块链

本文链接：https://blog.csdn.net/wobuxiangxin1314/article/details/129353397

版权

以太坊区块链私有链相关操作

以太坊区块链私有链相关操作

以太坊区块链私有链相关操作

小小怪专属

一、安装Geth（Windows版）

安装好后如图有两个文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aEL5XERb-1678259756155)(D:\学习\区块链\image\1.png)]

其中genesis.json是自己创建的文件，也就是创世区块（对整个私链进行初始化设置）

{
	"config": {
	"chainId": 123,
	"homesteadBlock": 0,
	"eip150Block": 0,
	"eip155Block": 0,
	"eip158Block": 0,
	"byzantiumBlock": 0,
	"constantinopleBlock": 0,
	"petersburgBlock": 0,
	"istanbulBlock": 0
	},
	"alloc": {
	 "0x634c4CF26680fa8C2Ef3d8B9FA4E6AE748667BB8": { "balance": "300000000000000000000000000000" }
	},
	"coinbase": "0x0000000000000000000000000000000000000000",
	"difficulty": "0x2000",
	"extraData": "",
	"gasLimit": "0xffffff",
	"nonce": "0x0000000000000042",
	"mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
	"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
	"timestamp": "0x00"
}

二、初始化Geth

初始化命令：（要在geth安装的根目录cmd再操作）

geth --datadir . init genesis.json

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MUROgGGP-1678259756156)(D:\学习\区块链\image\2.png)]

三、运行Geth客户端：

命令：（同样要在geth安装的根目录cmd再操作）

geth --datadir . --networkid 123 --nodiscover --http --http.addr 0.0.0.0 --http.port 8545 --http.corsdomain "*" --port 30305 –http.api eth,net,web3,personal --allow-insecure-unlock console 2>output.log

运行成功的界面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ru8qLcyc-1678259756157)(D:\学习\区块链\image\3.png)]

四、Geth客户端的相关操作：

1、eth

包含一些跟操作区块链相关的方法

查看所有的信息和eth下的方法
eth
枚举系统中的账户（可以通过下标取得对应的账号）
eth.accounts
查看账户余额，返回值的单位是 Wei（Wei 是以太坊中最小货币面额单位，类似比特币中的聪
(1 ether = 10^18 Wei)
eth.getBalance()
列出区块总数
eth.blockNumber
获取交易
eth.getTransaction()
获取区块
eth.getBlock()
发起交易  from发起者  to获得者  value交易数量
eth.sendTransaction({from:eth.accounts[0],to:eth.accounts[1],value:amount})
查看当前待确认交易
eth.getBlock("pending", true).transactions

2、net

包含一些查看p2p网络状态的方法

查看p2p网络状态和net下的所有方法
net
查看已连接到的节点数量
net.peerCount

3、admin

包含一些与管理节点相关的方法

查看节点信息以及admin下的所有方法
admin
iner.start(1)时使用该命令可以使新区块挖出后，就停止挖矿
admin.sleepBlocks(1)
查看当前节点的 enode 信息（用于节点的同步和加入）
admin.nodeInfo.enode
参数输入另一个NetWorkID相同的节点的enode 信息，就可以连接到该节点
admin.addPeer()
查看连接到的其他节点信息
admin.peers

4、miner

包含启动&停止挖矿的一些方法

查看miner下的所有方法
miner
开始挖矿
miner.start()
miner.start(1)
停止挖矿
miner.stop()

5、personal

主要包含一些管理账户的方法

查看所有的账户以及账户的密钥位置和personal下的所有方法
personal
创建账户
personal.newAccount()
解锁账户
personal.unlockAccount()

6、txpool

包含一些查看交易内存池的方法

查看交易内存池的所有信息
txpool
交易池中的状态
txpool.status

7、web3

包含了以上对象，还包含一些单位换算的方法

查看web3下的所有对象以及对象方法
web3
Wei 换算成以太币
web3.fromWei()
以太币换算成 Wei
web3.toWei()

五、MetaMask连接私链

MetaMask连接Localhost 8545

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oQrrs9js-1678259756158)(D:\学习\区块链\image\5.png)]

连接成功后到设置->网络修改Localhost 8545的链ID为123（创世区块中设置的链ID是123）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hMka96MD-1678259756159)(D:\学习\区块链\image\4.png)]

保存完成！

六、MetaMask导入私链账号

七、Remix编写合约

八、私有链合约地址

1、水龙头合约（Faucet.sol）

地址：0x60B587C65ef78e7Ba04D29bfA68a729A4226a56b

pragma solidity ^0.4.17;

contract Faucet {
    function withdraw(uint amount) public {
        require(amount <= 1000000000000000000000);
        msg.sender.transfer(amount);
    }
    function () public payable {}
}

2、NFTMarket（NFTMarket.sol）

地址：0x8DdC08135653292C568D7D5793e1b6a0bf530FC0

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
 
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
 
 
contract NFTMarket is ERC721,  ERC721Enumerable, ERC721URIStorage  {
    using Strings for uint256;
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    address private owner;
    mapping (uint256 => string) private _tokenURIs;
    
    string private _baseURIextended;
 
    constructor () ERC721("NFTMarket", "NFTMKT") {
    	owner = msg.sender;
	    //currToken = IERC20(_currTokenAddress);
	}
    
    function setBaseURI(string memory baseURI_) external {
        _baseURIextended = baseURI_;
    }
    
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual 
        override(ERC721URIStorage){
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }
    
    function _baseURI() internal view virtual override returns (string memory) {
        return _baseURIextended;
    }
    
    function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
 
        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();
        
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }
        return string(abi.encodePacked(base, tokenId.toString()));
    }
 
    function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
 
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal  override(ERC721, ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }
 
    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
        super._burn(tokenId);
    }
 
    function burnNFT(uint256 tokenId) public returns (uint256) {
        require(msg.sender == ownerOf(tokenId),"Only the owner of this Token could Burn It!");
        _burn(tokenId);
	    return tokenId;
    }
 
    function mintNFT(address _to,string memory tokenURI_) public returns (uint256){
        _tokenIds.increment();
 
        uint256 newItemId = _tokenIds.current();
        _mint(_to, newItemId);
        _setTokenURI(newItemId, tokenURI_);
 
        return newItemId;
    }
 
    function transNFT(address _from,address _to,uint256 tokenId) public returns (uint256) {
        require(msg.sender == ownerOf(tokenId),"Only the owner of this Token could transfer It!");
        transferFrom(_from,_to,tokenId);
        return tokenId;
    }
 
    function destroy() virtual public {
        require(msg.sender == owner,"Only the owner of this Contract could destroy It!");
        selfdestruct(payable(owner));
    }
}

3、NFT商家合约（NFTStore.sol）

地址：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
 
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
 
contract NFTStore is Context, ERC20 {
    address private owner;
    struct Mints {
        address minter;
	    uint256 amount;
    }
 
    mapping(uint256 => Mints) public tokenToMint;
    mapping(uint256 => uint256) private tokenAmounts;
    /**
     * @dev Constructor that gives _msgSender() all of existing tokens.
     */
    constructor (uint256 tokenNum) ERC20("NFTStore", "NFC") {
        owner = msg.sender;
        _mint(_msgSender(), tokenNum * (10 ** uint256(decimals())));
    }
 
    function mint(address _to,uint256 amount,uint256 tokenId) public {
        require(msg.sender == owner,"Only the owner of this Contract could mint!");  // 本文添加，否则函数 mint 会有逻辑错误
        _mint( _to, amount) ;    // 如果没有添加上一句 require，此处会有逻辑错误，任何人都可以免费获得NFC
        tokenAmounts[tokenId] = amount;
        Mints memory mintted = Mints({
            minter: _to,
            amount: amount
        });
        tokenToMint[tokenId]=mintted;
    }
 
    function getTokenAmount (uint256 tokenId) public view returns (uint256) {
        return tokenAmounts[tokenId];
    }
 
    function gettokenMints(uint256 tokenId) public view returns ( address, uint256){
        Mints memory mintted = tokenToMint[tokenId]; 
        return (mintted.minter,mintted.amount);
    }
    
    function destroy() virtual public {
	    require(msg.sender == owner,"Only the owner of this Contract could destroy It!");
        selfdestruct(payable(owner));
    }
}