Ethereum

What is Ethereum

Ethereum is a deterministic but practical unbounded state machine, consisting of a global accessible singlton state a vm that applies changes to that state.

Properties of Ethereum

1. Truly global singlton
   Ethereum is possible the first global singlton computer ever, that is fundamental not localized. Etherrum does not reside in any single machine, no physical presence in the world.

2. Cencorship resistance
   No one owner Ethereum or control it.

3. Ubiquitous and Accessible.
   if we want to write to the Ethereum computer, we only need have eth on top of the internet conection - to pay gas.
   solidity is similar to javascript. so the learning curb for new dev is not that particular difficult.

4. Mutil-User
   Wide input range of the keccack256 hash function, has a practical infinite range possible of creating account. the range is 2^160

5. Verifiable & Auditable
   When we deploy the smart contract, it’s permenant unless u explicitly code in clause with a call to selfdestruct.

Ethereum vs bitcoin

one of a key different between Ethereum and bitcoin is that Ethereum has a vm built into it that is support Turing-complete language. which means developers can build arbitrary application and program on top of it.
In contrast. bitcoin script language is purposefully restricted to simple true/false evaluation of condition correlating to whether or not UTXOs can be spent. it’s not allow loop.

Program is written in Turning-complete language have a properties that make it impossible to tell if those programs will ever terminated.

for(let i = 0; i >= 0; i++) {
  console.log(i);
}

because Ethereum lanuage is Turning-complete lanuage. so if we deploy above code in block, what will happend? A minaer would receive a transaction, add it to their transaction memory pool, mine a block. add the transaction to block, then broadcast the block to network. now, all the other node in the network will try to run this transaction on their owner machine, they will be stuck in a infinity loop..!

In order to prevent such attack occurs. Etherrum design a vm to run transactions within. it called EVM(Ethereum Virtual Machine)
Other differences between Ethereum and Bitcoin
Here’s the information formatted as a table in Markdown:

	ETHEREUM	BITCOIN
Consensus Mechanism	Proof of Stake	Proof of Work
Accounting System	Account Model	UTXO Model
Public Key Cryptography	secp256k1 elliptic curve	secp256k1 elliptic curve
Stale/Orphan Blocks	Rewarded (Ommer Blocks)	Not Rewarded
Block Time	Approx every 12 seconds	Approx every 10 minutes
Network Difficulty	Adjusted every block	Every 2016 blocks
Language Support	Turing Complete smart contracts, custom VM	non-Turing Complete scripts, VM operations cost gas

EVM

The EVM is similar to the JVM. In fact, JVM was considered as an optional to build Ethereum of before development began on the EVM. the problem is, the EVM had very specific requirements in order to run decentralized blockchain. Take, for example, that infinite loop from the previous section:

for(let i = 0; i >= 0; i++) {
  console.log(i);
}

how could we create a environment in which code like this would not be able to run infinitely.
it turns simplest way to do this by adding the monetary cost of each operation. this cost in Ethereum called “GAS”.

GAS

Gas is a measurement of the cost to each operation that relates to the computation cost that the operation incurs on the network. So if you are making every node in the network do some kind of computationally expensive task every time they need to verify your transaction, you’ll need to pay for significantly more than a simple transaction that is sending money from one individual to another

Even though the above cost is “fixed”, the actual price of the gas ever changed.

We can split these operations up into a several categories:

Arithmetic (i.e. ADD, DIV, etc.)
Information about the current context of the transaction (i.e. TIMESTAMP , CALLVALUE, etc.)
Operations that manipulate/retrieve from temporary memory (i.e. MSTORE, PUSH32, etc.)
Operations that manipulate/retrieve from persistent memory (i.e. SSTORE, CREATE, etc.)
Control Flow Operations that provide us with loops (i.e. JUMP, JUMPI, etc.)

if u want to take a look permanent state, u need to cost more gas than Arithmetic operations.

The Gas prices, Benchmarking centerinally help us to know gas prices. although in some ways this can be a bit of a guessing game. the goal is to find a gas cost that represents of the amount of starin the operation takes on the network.

FORK

DOS (denial of service)

In the past, attarckers try to exploit any discrepancies between computations expensive operation and their associated gas costs. These attack refrence to “DOS” they will slow the network to a crwl and deny uses of the service. Due of this, Ethereum upgrade the vm in order to adjust gas costs.

How does a decentralized network upgrade a vm running on thousands of machines? the answer is FORK

Understanding Fork.

Part of philosophy of Ethereum is embrace change and move fast. As such, Ethereum design with the ability to conduct upgrade. and build in a process for suggesting improvements to the system. Each upgrate is spcific in an Ethereum improvement proposal or EIP for shot.Anyone can suggest standards for Smart Contracts like the popular EIP20 Token Standard or changes to the Virtual Machine itself like this addition of the DELEGATECALL opcode. Updates to the VM require forks. To understand why, let’s consider how the EVM works.

Several teams used this specification and implemented the EVM in different languages. Each of these EVM implementations is called an Ethereum Client. Two commonly used Ethereum clients today are Erigon and Geth both written in Go (Parity used to be a popular client but was deprecated in 2020).

Some upgrads to the evm are planned and other is impromptu response for attrack. Either way, when these changes are to be adopted a fork occurs. this is because active nodes need to update their client with the latest changes spcific by the EIPs. it’s called “fork” because some node may choose upgrate and other may choose not.

Soft fork, backword compatible.

In other cases, especially updates that have political implications, clients may not adopt the new changes and may even fork client implementations. This is what happened in the case of the the DAO Fork which was a particularly contentious fork splitting the network into two competing blockchains: Ethereum and Ethereum Classic. You can see an example of a forked client by looking at the version of Geth that is maintained by the Ethereum Classic Labs.

Ethereum hard fork list

POS

POS(Proof of stake), as know as “merge”, the propoties of that Ethereum change POW to POS is

• more security
• less energy
• greater scalablities.

HOW POS Works

In POS, the energy requirement become a validator is much lower and can be done by individual without a high overhead energy cost.

Instead of using mass amount of electricity, validators are require to stake 32 ETH by deposing it into contract to have ability to validate blocks. The stake ETH is used as collerator against bad actors in the network. If any given any validators acts dishonest or malicious they put themselves at risk of losing their stake ETH.

Rather than all validators mine a block same time, the network randomly choose a validator to purpose a block every 12 seconds, then all of the other validators veirfy that the purpose block is correct, and the cycle repeats.

How POS affects dev

How PoS affects Ethereum Development
One of the largest ways that PoS affects Ethereum developers is with a new framework for block finality. Finality in blocks refers to how confident you are that the given block will not change or get forked away. For blocks that have been on the network for a very long time (older blocks) it is extremely unlikely that it will be removed from the canonical chain and therefor has high finality.

Proof of Stake introduced 2 new levels of finality that developers should consider when requesting data from the network: safe and finalized. Here is an overview of all “block tags”:

earliest: The lowest numbered block the client has available. Intuitively, you can think of this as the first block created.
finalized: The most recent crypto-economically secure block, that has been accepted by >2/3 of validators. Typically finalized in two epochs (64 blocks). Cannot be re-orged outside of manual intervention driven by community coordination. Intuitively, this block is very unlikely to be re-orged.
safe: The most recent crypto-economically secure block, typically safe in one epoch (32 blocks). Cannot be re-orged outside of manual intervention driven by community coordination. Intuitively, this block is “unlikely” to be re-orged.
latest: The most recent block in the canonical chain observed by the client, this block may be re-orged out of the canonical chain even under healthy/normal conditions. Intuitively, this block is the most recent block observed by the client.
pending: A sample next block built by the client on top of latest and containing the set of transactions usually taken from local mempool. Intuitively, you can think of these as blocks that have not been mined yet.

Gas On Ethereum

EIP-1559

As many of u may know, the price of gas is changes with every block, Historically, gas price in Ethereum was unpredictable and at times, high marking transactions inaccessible to most people.

However, EIP proposed to improve gas price caculation, knowen as EIP-1559. Instead of coving antiquated computation of gas price from before EIP-1559, it’s focus on how is works for current state of Ethereum.

Denominations of Ether

How is the price of gas set?

Every block has mimiumed amound of gas that can be used within it. This is how the numbers of transactions include within a block are determined. Every block has capacity to use 30 million gas but has target 15m gas total.

The price of gas is determined by the amount of demand for transactions. where demand is measured by how filled previous block was related to the target gas.

This base fee helps users select an efficient gas amount that is likely to get their transaction mined rather than wasting tons of money on unnecessarily high gas prices like we’ve seen in the past. These mechanisms also make it easy to predict future gas prices by looking at how “full” the previous blocks were.

• 16128921
  

• https://etherscan.io/block/16128922
  

we can see 16128921 only using 6.4 million gas instead of 15 million, so the block demand is not big enought, then next block will decrease the gasbase for increasing amount of transactions. That’s how calculation price of gas.

What happend to the base fee?

Instead of going straight into miners pocket. the base fee actually has burned. there several reasons for why base fee is burned instead of being given to miner

• This prevents the miner from circumventing the payment of the base fee since they have to pay at least base fee * # of transactions for the block that the mine
• buring the base fee also creates a deflation pressure on Ether as an asset since supply is being taken out the market

Setting the gas for your transaction

Turns out when you are sending a transaction, you’re not actually setting the base fee value, but rather your setting the max fee which represents the maximum amount that you’re willing to pay to get your transaction included. Luckily, unlike with the previous gas usage model, your transaction will only ever use the base fee** amount to execute, the rest of the value (max fee - base fee) will be return to you.

As a dApp develop you can actually create your own algorithm to determine how much gas to include in your transactions using endpoints like eth_feeHistory. If you’re interested in learning how to build this, check out How to Build a Gas Fee Estimator using EIP-1559.

How are miners paid?

Since the base fee is entirely burned, the new incentive for miners is now known as the miner tip. In a perfect world, the miner tip is the minimum amount that the miner is willing to accept in order to execute your transaction. This tip was originally set as 1gwei but can fluctuate depending on how full blocks are. Since the target gas value in blocks is 15M, in general, so long as blocks are hitting or near the target amount, there will always be room to add more transactions within a block. This is why the miner tip does not need to be insanely high to get your transaction included.

Typically when you set the gas for your transaction you’re setting a value called maxPriorityFee which is equal to the max fee + the miner tip . We’ll learn more about sending transactions later on this week!

Account in Ethereum

EOA

Externally Owned Accounts (or EOA for shot) are similar to bitcoin pri/pub keys. In both models, the address and public key are associated to private key via an Elliptic Curve Digital Signature
The different between Account model and UTXOs:

• Ethereum is a 40 character hexadecimal string, Bitcoin is 26-35 alphanumeric string in Bitcoin
• Bitcoin addresses end in checksum to ensure the address typed properly.Ethereum addresses don’t have a checksum by default, although EIP-55 introduced a capitalization scheme that can be validated by wallet software.
  The biggest different is EOAs have balance. This means the global state of blockchain actively track how much ether active address on the network holds.

🤓 Minor clarification here: an active address refers to an address that has interacted on the Ethereum blockchain. There are technically 16^40 (or 2^160 if you’re thinking in binary!) possible Ethereum addresses which can be generated. These addresses are not included in the global state tree until they have interacted with the blockchain. Otherwise, this would be a massive amount of data stored! Take a look at (EIP-161)[https://github.com/ethereum/EIPs/blob/master/EIPS/eip-161.md] which was implemented when flaws in the Ethereum system allowed an attacker to create 19 million accounts at extremely low gas costs.

Account vs UTXOs

To transfer money in bitcoin we spend UTXOs. In Ethereum there are no UTXOs. Instead, at the end of the transaction transfering ether, the the transfered amount is subtracted from the sender’s balance and add it to recipient’s address balance in the global state tree.

Compare to UTXOs, an account balance is quiet straightforward, especially for dev, we can get the address balance just use balance operation that EVM support inside code running on the EVM

Each Ethereum address also contains nonce, the nonce keeps a count of all transactions sent from that particular address.
Let’s say you have 2 ether in your account and you want to send 1 ether to Bob:

{
  to: BOBS_ADDRESS,
  value: 100000000000000000 // 1 ether
}

You’ll be able to broadcast this transaction to the network once you sign it with your private key. 🔑🌐

At that point, with the current parameters specified, what’s stopping Bob from re-transmitting this same transaction again to the network? 🤔

NOTHING😱

To combat this, Ethereum tracks the number of transactions sent by an account, called the account nonce. Each time a transaction is sent, the nonce is incremented:

{
  to: BOBS_ADDRESS,
  value: 100000000000000000, // 1 ether
  nonce: 0x0 // this is the first transaction, nonce is zero!
}

If Bob tried to re-broadcast the transaction now, the network would reject it. Once the first transaction is successfully mined the miners enforce the rule that the nonce of your next transaction should be 0x1.

💭 You may be thinking: “What if Bob tried to increment the nonce himself?” But, of course, Bob would need you to sign the transaction after he incremented the nonce. The result of a digital signature does not leave room for the underlying data to be tampered with.

the nonce is simply means a number we’re using once for its particular purpose.

To summarize, the difference between Ethereum EOAs and Bitcoin addresses is that active EOAs are stored with a balance and a nonce. Whereas in Bitcoin the client only keeps track of UTXOs which contain an owner address.

Contract Accounts

Smart contract, it’s simply a program that runs in the blockchain execution environment.
As a dev, we will write smart contract. once we do that, we can deploy the contract in Ethereum blockchain. we can do this by running a transaction from our EOAs with the bytecode of the compiled the smart contract.

The contract have account, since that it also have address and balance. The contract account can’t be controlled by the private key. Instead, the EOAs make a transaction to call function on contract. From here, the contract can also make a call to another contract synchronously. Once the contract deploys, the contract code can’t be changed, but also it can updated by transaction.

📖 A contract can store an address of another contract that it needs to interact with. Since the address is held in storage it can be updated through transactions. Therefore it’s possible to upgrade a system by deploying new contracts and running a transaction to update references to point to the new addresses. This can be a bit of a challenging subject and is generally referred to as smart contract upgradeability.

The summary of Ethereum

(summary)[https://university.alchemy.com/course/ethereum/md/63911a1ffdaf860004511e98]

JSON-RPC

The way for communicating with Ethereum computer.

The above image simply shows that JSON-RPC is a bridge we use to connect any dApp we use/build to Ethereum node, and thus greater Ethereum network.

Ethereum clients

To run Ethereum node, we must run Ethereum client.These Ethereum clients use JSON-RPC, and thus define methods like eth_getBlockByNumber that are by-default queryable by any JSON-RPC compatible Request

JSON-RPC Concept

JSON-RPC is a api standard just like REST standard.

Thanks to every Ethereum node containing a JSON-RPC interface, we can communicate with the Ethereum blockchain in an instant. We can make important READ requests like eth_getBlockByNumber and eth_getBalance to the Ethereum blockchain at any time.

Ethereum client and node, what each means and the difference.

In the first, Term “client” and “node” are often used interchanged but there is difference.
Ethereum client: It’s software needed to allow Ethereum node read/write block on Ethereum blockchain and Ethereum-based smart contract. “node” is running piece of the client software. In order to run node, u must download client and run it.

Three Types of Node:

• Full Node

Full node are full of the data, they store and can destribute all of the data from the Ethereum network. Full node will additionally participate in block verification.( verify all blocks and states on the network).

An advanced of implement full node which it can interact with any smart contract on public blockchain. Full node can also directly deploy smart contract into any public blockchain.

However, the full use and store of data, as well as directly deploy smart contract, comes at cost. Full node can be taxing on ur computer hardware and bandwidth resources. Retrieving entries data may cost a lot of time. sometimes ur first deploy node may will take a few days to synchronize. and then, the node must be maintained, updated, keep it online in order to not have to repeat full synchronization again.

• Light Node

Light Node is similar to full node but handle less information. The header store header chain information(the basic information been stored in the blcok, such like timestamp and hash of previous block). But it only receive information from the request. it can verify the validity of data, but not fully participate in the verification process. the light node almost implements on remote client. Because these node not take on more intensive IO. they already been improved useful for the smart phone or anthor small store equipment.

• Achieved Node

Achivement Node is store all information from full node and builds achivement of historic state of block. evan as the client has been synchronized, the Achievment node still keep store all the data. on one the other hand, the Achievment node and light node will “prune” the history blockchain data. that’s means it can be re-build, but do not retrain this information.

Any of the client can run above node.

What’s Client

Client is helpful for developer, because they can let deve using a lot of programming languages interact with network and other network nodes. Ethereum client mintains several client for several languages. inclding GO, RUST, Java and C++.
Geth (Go)
OpenEthereum (Rust)
Nethermind (C#, .NET)
Besu (Java)
Erigon (Go/Multi)

Type of Ethereum Client

• Full Client
  Full client store all data of the Ethereum blockchain. the progress may take a few days to synchronize and requires a huge amount of disk space. exactly 1T. Full node client allow the conact node executes all task in network. including dige, transaction, block headers verification and smart contract running.
• Light Client
  Light Client is similar to Full client, but it not store all data of the Ethereum blockchain. therfore, it always deal with smart contract and broadcast transactions. other use cases include web3 instance in javascript, dApp browser and retrieving exchange rate data.
• Achivement Client
  Achivement client always used to be wallet for send and receive transactions.

Difference between Client and Node

Node and Client work together, both term used to be interchanged. However, they both opeart separately in order to access the Ethereum network.

Think of nodes and clients operating like a computer accessing the internet: the node is an operating system, like Windows or iOS, and the client is the computer itself. The client computer gives a user the ability to access the node operating system, which in turn, gives you the ability to access the internet. Different computers will be able to give you access to the same operating system and the different operating systems will give you access to the same internet.

Read more information if u are interested with client and node

Transaction in Ethereum

The key of the concept of transaction is transaction driver blockchain state changing. Ehereum is account-based system. it have two types of accounts, EOA and contract account. EOAs controled by human, that’s only way human dircity infect Ethereum unless EIP. the contract account(address) is used to as a call for transaction (that’s need be makeed by human). both of account have balance and address, the different between both is contract have storage hash and code hash.

additionally, we also have two types of transactions.

• Contract creation, it’s used to create smart contract.
• Message Call, it’s used to update the smart contract.

This is all of the information abount this section, we can see that first of all, the EOAs make different decisons, if he want to insepect balance or anthor thing, he just use JSON-RPC(withour signed). but if he need write or change blockchain state that he need signed!. once transaction have been completed, the nounce of transaction will be genreated.!

Transaction Object Example
Alice sends Bob 1 ETH

{
  to: "0x2c8645BFE28BEEb6E19843eE9573b7539DD5B530", // Bob
  gasLimit: "21000",
  maxFeePerGas: "30", // 28 (base) + 2 (priorityFee)
  maxPriorityFeePerGas: "2", // minerTip
  nonce: "0",
  value: "100000000000000000", // 1 ether worth of wei
  data: '0x', // no data, we are not interacting with a contract
  type: 2, // this is not a legacy tx
  chainId: 4, // this is AU, we deal only in test networks! (Göerli)    
}

Alice calls a function on a smart contract

{
  to: "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8", // smart contract address
  gasLimit: "36000",
  maxFeePerGas: "30", // 28 (base) + 2 (priorityFee)
  maxPriorityFeePerGas: "2", // minerTip
  nonce: "1", // this is Alice's second transaction, so the nonce has increased!
  value: "100000000000000000", // 1 ether worth of wei
  data: '0x7362377b0000000000000000000000000000000000000000000000000000000000000000', // this calldata tells the EVM what function to execute on the contract, contains parameter values here as well
  type: 2, // this is not a legacy tx
  chainId: 4, // this is AU, we deal only in test networks! (Göerli)    
}

How To Manually Construct Calldata
Once we send a transaction that points to a smart contract, how does the contract know what specific function you intend to call? Well, all those specifics end up going in the data field of each transaction.

Here is the algorithm to manually construct calldata:

1. Say Alice wants to call the withdrawEther() function of a faucet smart contract…

2. Alice must take the keccak256 hash of that function signature:

The resulting output is: 7362377b8e2cc272f16ab5d5441f976bd53fd78ccd01e3c67a1f6b2efdae09e0

3. Take the first 4 bytes (8 characters) of the hash output, which is just: 7362377b

4. This function takes no arguments, so no need to append any parameter data

• If the function took arguments, you would need to hash the entire function signature with that parameter type, for example: helloWorld(uint256)
• Final calldata construction, padded out to 32 bytes: 0x7362377b0000000000000000000000000000000000000000000000000000000000000000

aka

ethereum: 以太坊
Blockchain: 区块链
Crypto： 加密
crytocurrencts: 加密货币
decentralized: 去中心化
bitcoin： 比特币，第一个基于区块链技术实现的加密货币
fiancial incentives： 金融奖励
mining the rewards： 挖矿
deterministic: 确定性
pseudorandom: 伪随机
collsion resistant: 抗碰撞
consensus: 共识，一个网络对数据的状态达成共识。
censorship：审查
bribe： 贿赂
drill home： 钻研
relatively travel：相对较小的
infeasible： 不可能
symmetric: 对称
digital signature: 数字签名
RSA: 非对称加密的经典实现
ECDSA： bitcoin采用的非对称加密算法
ether： 以太币
address： 交易发起方类似于ip, bitcoin 使用checksum and base58, ethereum is last 20 bytes of the hash of the public key.
Enforcement： 执行
consensus rules： 共识规则
consensus mechanisms：协商一致
inter-changeable: 可互换的
cumulative: 积累型
nakamoto consensus： 最长的chain将是其他节点接受的一个真正的链，他是由一条链积累的工作所决定的。
txs: transactions.
pos: proof of stack, pos中，参与者需要持有一定数量的crytocurrency，参与记账过程，相比pow，pos不需要大量的算力
pow: proof of work，miners通过计算来添加txs和block，需要消耗算力。可以增加security of blockchain
merkle root：默克尔根，用来验证和确认交易是否被篡改。
underlying: 底层
hashcash： Hashcash工作量证明功能由Adam Back于 1997 年发明，并建议用于反 DoS 用途
Byzantine General’s Problem： 在p2p场景下，如何证明每个机器都是在工作的。
manipulate： 操作
Genesis Block: 第一个加入到区块链中的块，初始块
cost-effective: 成本效益
UTXO：Unspent Transaction Output, 未使用的交易
Retrospective： 回顾
vulnerable： 脆弱的
light nodes: 轻节点 （存储块头的轻节点）
full nodes：完整节点（常规节点）
achieve nodes: 归档节点， 完整节点（已验证的存档节点）
bandwidth： 带宽
configure: 配置
variables： 变量
discrepancies： 差异
tradeoffs： 权衡利弊
contrast： 对比
unfakeable： 不可伪造
replicate： 复制
Satoshi: “Satoshi” refers to the smallest unit of the cryptocurrency Bitcoin
individual： 个人
multitude： 众多的
aggregate： 总数
expedite： 加快
hefty prize ： 巨额奖金
controlled supply： 受控供应
intentional: 故意的
quirk： 怪癖
denial: 否认
distinguish： 辨别
preceding： 前面
emerge： 出现
hierarchically: 层次分明
intimidating： 令人生畏的
underneath： 底下
infacting：连接
concatenate： 串联
optimization： 优化
inconsistencies: 不一致
deveration: 推导
arbitrary： 随意的
immutable： 不可变
implications: 含义
ledger： 账本
traversal: 遍历
PMTs: Partricia Merkle tries
sealed: 密封.
Permenant: 永恒的
Ephemeral： 短暂的
Constantly: 不断的
prefixes: 前缀
recursion: 递归
portion： 部分
adjacent: 邻近的
neat mechanisms: 整洁的机制
consists: 包含
crowdfunding: 众筹
parse： 解析
intimidated: 吓坏
deterministic: 确定性
infrastructure： 基础设施
constrain： 限制
reside： 贮存
presence: 存在
cencership: 审查制度
auditable：可审查
Ubiquitous： 无处不在
barries： 障碍
curb： 抑制，阻止
comprehend： 理解
easy as pie： 易如反掌
explicitly：明确的
clause： 条款
neutrality；中立
arbitrary： 随意的
EVM： Etherrum Virtual Machine
Stale/Orphan block： 陈旧/孤立块，是指在一个区块同时被矿工挖掘出，区块可能会出现临时分叉，未能被选为有效区块的区块被称为stale/Orphan block，在Etherum中此类区块又称为Ommer block，是Etherrum作为鼓励和奖励矿工为安全做出贡献的机制。
emulate： 模仿
underlying： 潜在的
monetary： 货币
fixed： 固定的
Arithmetic: 算术
benchmarking: 基准测试
discrepancies: 差异
philosophy: 理念
Ethereum improvement proposal: EIP， Ethereum 改进提案
first and foremost: 首先
specification： 规范
adhere: 符合
impromptu： 即兴
compatible： 兼容的
contentious： 有争议的
overHead：高昂的
collateral: 抵押物
intuitively: 直观的
re-orged： 重组
manual：手动的
intervention： 干涉
canonical: 经典的
shifted： 转移
denomination: 面值
demand： 需求
circumventing： 规避
deflationary: 通缩
deprecated: 弃用
redunant: 多余的
tampered: 被篡改
EOAs: Extended owned account.
Vulnerability: 漏洞
JSON-RPC: remote procedure call(rpc) protocal that uses JSON to encode message.
exclusively: 只，仅仅 equied to only
instruction: 指令
term: 术语
boilerplate: 样板
pioneer： 先锋
lucrative: 有利可图
mnemonic: 助记词
configured： 配置
specified： 指定的
analogues： 相似的
discarded： 丢弃
underscore preceding: 前下划线
snippet： 片段