区块链开发基础介绍

区块链开发基础介绍，理解什么是区块链开发，以及包含的技术点…

区块链基础

区块链是一种去中心化的分布式账本技术，它使用加密算法来保证数据的安全性和不可篡改性。

更通俗的理解方式：

用户通过网页调用部署在服务器(ubuntu,centos…)上的后端服务(java,python,go..)来修改获取数据库中的数据

用户 → 外部账户（ Externally Owned Account, EOA ）用户实际控制的账户 (address)

服务器 → 区块链(以太坊)

后端服务 → 合约(solidity)

用户address通过调用部署在区块链中的合约来修改获取合约中的数据

外部账户信息

账户的产生：
私钥–公钥–地址

Private key 就是一份随机生成的256 位二进制数字。用户甚至可以用纸笔来随机地生成一个私钥，即随机写下一串256 位的仅包含“0”或“
1”的字符串。该256 位二进制数字就是私钥最初始的状态。私钥是用于签署交易和发送以太币的关键
Public Key 通过私钥进行椭圆曲线运算而生成的，是一个512位的二进制数，通常表示为64个十六进制字符。
Address 对公钥进行Keccak-256哈希运算而得到的，每个账户都有一个唯一的地址，由20个字节组成，通常表示为40个十六进制字符。

账户属性:

balance:余额–余额的作用
nonce:累积次数

KeyStore:
它包含了加密的私钥，以及一个密码（也称为解锁密码）来解密私钥。

{"address":"0981960bc0612561ea8104e5d3f9f2f8ea594e8f","id":"d0eae1f0-1110-406a-be24-5691b0c5fbf3","version":3,"
crypto":{"cipher":"aes-128-ctr","ciphertext":"847a61e99196fe3beb4c148ae7634c00fd5c4303173245aa44e555141fa628cf","
cipherparams":{"iv":"5aa4b65214b7632ca5729d2293923908"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":4096,"p":6,"r":8,"
salt":"d349a51b5f62f26ce1fb71613d8d1907825c55dce1d24d1abda4c11c65a0221f"},"mac":"
0e01455e188fdcadbb3a176072fe542479a705b47091112915e889773859a6a5"}}

区块链信息

区块–区块（Block）是构成区块链的基本单元。所谓的区块，其实可以定义为记录一段时间内发生的交易和状态结果的数据结构，是对当前账本状态的一次共识。每个区块包含了一定数量的交易数据以及一些元数据，例如时间戳、前一区块的哈希值、难度目标等。

共识机制：新的区块通过（*）方式被添加到区块链。满足所有节点都同意接受相同的区块链数据和状态。

链–链表

节点–去中心化，相互验证和存储交易数据。多个节点验证和确认，从而防止了恶意行为和双重支付等攻击。任何人都可以加入网络，并参与到区块链的维护和管理中。

以太坊数据结构

合约信息

合约账户(合约地址)产生：合约账户是通过将智能合约的字节码上传到以太坊区块链上来创建的。合约账户不是由私钥文件直接控制，而是由合约代码控制。地址是通过部署合约时使用的地址和合约创建时的
nonce 计算得到的哈希值。

合约账户属性：

balance（账户余额）
nonce（计数器）//一个合约可以调用另外一个合约，所以要通过nonce值记录一下调用的次数。
code（代码）
storage（相关状态-存储，包括每个变量的取值，合约的状态变量存储在区块链上，并且在合约执行过程中可以被读取和修改。）
creator(创建者，通过发交易来创建)

外部账户和合约账户的区别：

是否拥有私钥
是否可以发送交易（合约账户不能主动发起一个交易，以太坊中的一个规定，所有的交易只能由外部账户发起，外部账户发起一个交易如果调用了一个合约账户，这个合约账户可以发送一个message调用另外一个合约，但是他不能自己品平白发起一个交易。）

外部账户代码交互

/*
 * 生成keystore文件
 * @param privateKey 私钥
 * @param password 私钥密码
 * */
public static String generateKeyPair(String privateKey, String password) throws Exception {
   ECKeyPair ecKeyPair = ECKeyPair.create(new BigInteger(privateKey, 16));
   WalletFile walletFile = Wallet.createLight(password, ecKeyPair);
   return JacksonUtil.obj2json(walletFile);
}

/*
 * 解密keystore文件
 * @param keystore keystore字符串
 * @param password 私钥密码
 * */
public static ECKeyPair verifyKeyPair(String keystore, String password) throws Exception {
   WalletFile walletFile = JacksonUtil.json2pojo(keystore, WalletFile.class);
   return Wallet.decrypt(password, walletFile);
}

/*
 * 通过私钥密码生成钱包账户信息
 * @param password 私钥密码
 * */
public static WalletFileUser createWallet(String password) throws Exception {
   WalletFileUser walletFileUser = new WalletFileUser();

   ECKeyPair ecKeyPair = Keys.createEcKeyPair();
   WalletFile walletFile = Wallet.createLight(password, ecKeyPair);

   walletFileUser.setAddress(CommonUtil.removeHexPrefixIfExists(walletFile.getAddress()));
   walletFileUser.setPublicKey(Numeric.toHexStringNoPrefix(ecKeyPair.getPublicKey()));
   walletFileUser.setPrivateKey(JacksonUtil.obj2json(walletFile));

   return walletFileUser;
}

交易-Transaction

交易的概念

交易（Transaction）是指发送者向接收者发送以太币或者调用智能合约需要被记录的操作(行为)。这个记录被称为交易哈希（Transaction Hash），它是对交易数据进行哈希计算后的结果。

交易的状态

成功（Success）：
- 交易被成功执行，并且在区块链上产生了相应的状态变化。
- 如果是发送以太币，发送者的余额会减少，接收者的余额会增加。
- 如果是调用智能合约，智能合约中定义的方法会被成功执行，并可能产生状态变化或触发事件。
失败（Failed）：
- 交易执行失败，没有在区块链上产生相应的状态变化。
- 失败的原因可能是 gas 不足、合约代码错误等。
挂起（Pending）：
- 交易已经被广播到网络中，但还没有被包含在区块中。
- 在交易被打包到区块之前，交易的状态为挂起。
确认中（Pending Confirmations）：
- 交易已经被包含在区块中，并且区块已经被添加到区块链上。
- 但是交易还没有获得足够的确认数，尚未被确认。
已确认（Confirmed）：
- 交易已经被包含在区块中，并且已经获得了足够的确认数。
- 一般情况下，交易需要在多个区块中获得确认才被视为有效。
已取消（Cancelled）：
- 交易被发送者取消，或者因为 gas 价格过低被矿工拒绝包含在区块中。
- 这种状态下，交易不会被执行，并且不会在区块链上产生相应的状态变化。
超时（Timeout）：
- 交易在一定的时间内没有被打包进区块中，被认为是超时状态。
- 这种情况下，交易会被重新发送或者取消。

交易的执行过程

创建交易-用户从Dapp或者钱包初始化一笔交易，转账交易或者调用智能合约。。
签名交易-用户使用它们的钱包（私钥）签名这个交易。
发送者将签名后的交易广播到以太坊网络中的节点。
网关节点验证该交易有效并将它放入自己的内存池（交易池/交易队列）中。此时，该交易为Pending状态，所有人都可以读取（前提是提供该项服务）。进入pending状态的交易代表着将要被交易，具体交易区块由打包矿工决定。
网关节点将该交易向其它节点（邻近节点）扩散（广播）。这是个Pending交易传播过程。
它节点接收到该交易后也验证有效性，然后放入自己的内存池中。然后再向其它节点扩散。这是其它节点将pending放入自己的内存池中。
重复上述步骤，直到该交易扩散到整个网络。
矿工是一种特殊节点，它们除了接收交易和验证它以外，还试图把它加入一个区块。矿工特权，具有打包交易的权利。
最终，会有一个矿工将该交易打包到区块中（这里假定交易成功并且会被打包）并添加到区块链上（产生一个新区块）。这就是通常所说的挖矿（出块）。
新产生的区块向全网广播。（以太坊大概13秒左右出一个块，基本上能够全网广播）。
所有节点接收到该区块，查看其中包含的交易并将其从自己的内存池中移除。

区块链交互

以太坊JSON RPC手册 / eth_getBalance - 汇智网

获取当前区块高度 cast block -r http://localhost:8545
获取指定区块信息 cast block -r http: //localhost:8545 1425668
获取账户余额 cast balance -r http: //localhost:8545 0xf4267391072b27d76ed8f2a9655bcf5246013f2d 
获取账户nonce cast nonce -r http: //localhost:8545 0xf4267391072b27d76ed8f2a9655bcf5246013f2d
获取交易信息 cast tx -r http: //localhost:8545 0x6813c06bc1fe1f7962cb6776a08c17c84f1fd6a74dc2631fd3f2dd602e0f82d6
获取交易收据 cast receipt -r http://localhost:8545 0x6813c06bc1fe1f7962cb6776a08c17c84f1fd6a74dc2631fd3f2dd602e0f82d6

区块链合约交互

交互API

call信息 cast call
send  cast send

创建filter
curl --data '{"jsonrpc":"2.0","method":"eth_newFilter","params":[{"fromBlock": "0x15C192","toBlock": "0x15C19C","address": "0x27EddE8d0dF786996E5e389AcbdfE804ba9eaDb6","topics": ["0x9283ff3607e3da47fe0733402e95abd90472527fbbac5a26edffcbd508134773"]}],"id":1}' -H "Content-Type: application/json" -X POST localhost:8545

获取filter log
curl --data '{"jsonrpc":"2.0","method":"eth_getFilterLogs","params":["0x414e11d56b274f9ca5fd760c1c725e6e"],"id":1}' -H "Content-Type: application/json" -X POST localhost: 8545

获取filter log change
curl --data '{"jsonrpc":"2.0","method":"eth_getFilterChanges","params":["0x414e11d56b274f9ca5fd760c1c725e6e"],"id":1}' -H "Content-Type: application/json" -X POST localhost: 8545

日志解析

合约数据类型：

静态类型在编译时可以确定其大小和存储位置:bool,int,uint,address，bytes1-32，enum
动态类型：bytes，array[]，mapping，string

三方库交互

 public BigInteger getBlockNumber() throws Exception {
   return this.w3.ethBlockNumber().send().getBlockNumber();
}

public Block getBlockByNumber(BigInteger blockNumber) throws Exception {
   return this.w3.ethGetBlockByNumber(DefaultBlockParameter.valueOf(blockNumber), true).send().getBlock();
}

public BigInteger getBlockTimestamp(BigInteger blockNumber) throws Exception {
   return this.getBlockByNumber(blockNumber).getTimestamp();
}

public Block getBlockByHash(String blockHash) throws Exception {
   return this.w3.ethGetBlockByHash(blockHash, true).send().getBlock();
}

public BigInteger getBalance(String address) throws Exception {
   return this.w3.ethGetBalance(address, DefaultBlockParameterName.LATEST).send().getBalance();
}

public List<Transaction> getTransactionsByBlockNumber(BigInteger blockNumber) throws Exception {
   List<Transaction> txs = new ArrayList<>();
   Block block = getBlockByNumber(blockNumber);
   if (block == null) {
      return null;
   }
   for (TransactionResult<Transaction> tx : block.getTransactions()) {
      Transaction t = tx.get();
      txs.add(t);
   }
   return txs;
}

public Transaction getTransactionByHash(String transactionHash) throws Exception {
   return this.w3.ethGetTransactionByHash(transactionHash).send().getTransaction().get();
}

public BigInteger getAddressNextNonce(String address) throws Exception {
   return this.w3.ethGetTransactionCount(address, DefaultBlockParameterName.PENDING).send().getTransactionCount();
}

public BigInteger getGasPrice() throws Exception {
   return this.w3.ethGasPrice().send().getGasPrice();
}

public BigInteger estimateCallContractGas(String fromAddress, String contractAddress, String functionName,
                                          Type... functionArguments) throws Exception {
   String data = EthTransactionUtil.encodeFunction(functionName, functionArguments);
   org.web3j.protocol.core.methods.request.Transaction requestTransaction =
           new org.web3j.protocol.core.methods.request.Transaction(fromAddress, BigInteger.ZERO, BigInteger.ZERO, null,
                   contractAddress, BigInteger.ZERO, data);
   EthEstimateGas estimateGas = this.w3.ethEstimateGas(requestTransaction).send();
   return estimateGas.getAmountUsed();
}

public Optional<TransactionReceipt> getTransactionReceipt(String transactionHash) throws Exception {
   return this.w3.ethGetTransactionReceipt(transactionHash).send().getTransactionReceipt();
}

public BigInteger createFilter(BigInteger blockStart, BigInteger blockEnd, String contractAddress, String... topics)
        throws Exception {
   EthFilter requestEthFilter = new EthFilter(DefaultBlockParameter.valueOf(blockStart),
           DefaultBlockParameter.valueOf(blockEnd), contractAddress);
   requestEthFilter = requestEthFilter.addOptionalTopics(topics);
   return this.w3.ethNewFilter(requestEthFilter).send().getFilterId();
}

public List<Log> getFilterLogs(BigInteger filterId) throws Exception {
   List<Log> logs = new ArrayList<>();
   EthLog ethLog = this.w3.ethGetFilterLogs(filterId).send();
   for (LogResult<Log> log : ethLog.getLogs()) {
      Log l = log.get();
      logs.add(l);
   }
   return logs;
}

public String readContract(String contractAddress, String data) throws Exception {
   org.web3j.protocol.core.methods.request.Transaction requestTransaction =
           new org.web3j.protocol.core.methods.request.Transaction(EthConstant.BLACK_HOLE_ADDRESS, BigInteger.ZERO,
                   BigInteger.ZERO, EthConstant.DEFAULT_GAS_LIMIT, contractAddress, BigInteger.ZERO, data);
   EthCall ethCall = this.w3.ethCall(requestTransaction, DefaultBlockParameterName.LATEST).send();
   if (ethCall.isReverted()) {
      return ethCall.getRevertReason();
   }
   return ethCall.getValue();
}

private String sendRawTransaction(String privateKey, RawTransaction rawTransaction) throws Exception {
    long chainId = this.w3.ethChainId().send().getChainId().longValue();
    String signedTx = EthTransactionUtil.signRawTransaction(rawTransaction, chainId, privateKey);
    if (signedTx != null) {
        EthSendTransaction transaction = this.w3.ethSendRawTransaction(signedTx).send();
        return transaction.getTransactionHash();
    }
    return null;
}

public Result<String> dryRunCallContractRawTransaction(String privateKey, String contractAddress, String functionName, Type... functionArguments) throws Exception {
   EthTransactionParam ethTransactionParam = this.constructEthTransactionParam(privateKey);
   String functionEncoder = EthTransactionUtil.encodeFunction(functionName, functionArguments);
   org.web3j.protocol.core.methods.request.Transaction requestTransaction =
           new org.web3j.protocol.core.methods.request.Transaction(ethTransactionParam.getAddress(), ethTransactionParam.getNonce(), ethTransactionParam.getGasPrice(), ethTransactionParam.getGasLimit(), contractAddress, BigInteger.ZERO, functionEncoder);
   EthCall ethCall = this.w3.ethCall(requestTransaction, DefaultBlockParameterName.LATEST).send();
   Result<String> result = new Result<>();
   if (ethCall.isReverted()) {
      return result;
   }
   result.setData(ethCall.getValue());
   return result;
}

区块链

#区块链开发

区块链开发基础介绍

https://zhyyao.me/2023/08/31/blockchain/chain_basic/

作者

zhyyao

发布于

2023年8月31日

许可协议

以太坊数据结构上一篇

fork函数、孤儿进程和僵尸进程下一篇