Shulou(Shulou.com)06/01 Report--

This article mainly introduces "what are the Solidity knowledge points for the old programmers". In the daily operation, I believe that many people have doubts about the Solidity knowledge points for the old programmers. The editor consulted all kinds of materials and sorted out the simple and easy-to-use operation methods. I hope it will be helpful to answer the questions of "what are the Solidity knowledge points for the old programmers?" Next, please follow the editor to study!

1EVM and bytecode

Like Java code, Solidity code is compiled into bytecode and then executed by EVM. Logically, Ethernet Fong can be thought of as a computer, where each EVM node is similar to a process executed in a computer, and the distributed ledger is the storage of this computer.

Once the deployment is successful, the code is copied to other nodes on the Ethernet Square, and the source code can be viewed by command. Take the Truffle development environment as an example:

Truffle develop

Deploy MyCoin contract, deploy

MyCoin.at (address), and you can see the contract code from the source property in the json object that it returns.

The contract cannot be updated after deployment, which poses a considerable challenge for developers:

How to develop a high-quality contract without Bug as much as possible?

How to design scalable contracts?

2 execution cost

When it comes to the cost of program execution, it generally refers to the amount of memory, storage, and CPU time spent. But in addition to these usual costs, it takes real money to execute the code on Ethernet Square. This is because the confirmation of transactions in Etay Square costs money! They are mainly those operations that change the state of Ether Fong, such as:

Account transfer

Deployment contract

Write operations in the contract

And, unlike other systems, the results of these operations do not take effect immediately. They will be submitted in the form of transactions to the trading pool for miners to confirm, which is where the transaction fees come from. Moreover, the price is not a fixed value, it fluctuates up and down with the fluctuation of the market. If your trade doesn't work out for a long time, you can see if it's because the transaction fee is too low.

You can learn about the transaction fee from the latest transaction (https://etherscan.io/txs).

This also poses a challenge for developers: how to reduce transaction costs as much as possible on the premise of implementing functions?

3 accounts

In order to operate on Ethernet Square, you must have an Ethernet Square account. There are currently two types of accounts:

An external account, which can be simply thought of as a "human user", has a private key and balance, and the transaction is signed with the private key before it is sent.

After the contract account is deployed, there should be an account with the balance and the corresponding contract status data. It triggers execution by an external message. The trigger source comes from an external account or other contract account.

There are also some conceptual shifts in security:

The private key is the ultimate secret and must be stored locally, otherwise it is insecure.

Since the contract is public, anyone can initiate and execute it. If you want to achieve "only xxx can execute this contract", you must control it in the internal code of the contract.

4 contract grammar

A contract is similar to a class in Java, but unlike a class, its constructor is called only once, that is, when the contract is deployed.

The state variable of the contract is equivalent to the instance variable of the class, but it is also persistent. Also, mapping can only be declared as a state variable but can be referenced within a function.

Variable types also score types and reference types, where reference types include arrays and structs, which provide schemes for custom types.

The function can return one or more values, and you can specify the variables to return. Such as:

Function arithmetic (uint _ a, uint _ b) public pure returns (uint o_sum, uint o_product) {o_sum = _ a + _ b; o_product = _ a * _ b;}

Function modifiers (Modifier), similar to interceptors in AOP, provide an opportunity to modify the flow of function execution, which is generally used for verification and checking. Where "_" is used to return the control flow to the modified function, such as the following example:

Modifier onlySeller () {/ / Modifier require (msg.sender = = seller, "Only seller can call this."); _;} function abort () public onlySeller {/ / Modifier usage /.}

Several important modifiers:

Payable, the function that receives the ether must be added

View or pure, indicating that the function does not change the ethernet state

Events provide a way for external applications to understand the changes in contract status, and the general usage process is as follows:

Events issued within the contract

External applications use web3 to listen for events

Visibility:

External, which applies only to functions, means that it can be called by an external contract or transaction, but not internally.

Public

Function default visibility, which can be called internally and through messages

State variable for which EVM automatically generates getter

Internal, functions and state variables can be called by the current contract and its subcontracts

Default visibility of state variables

Private, functions and state variables are only called by the current contract

Contracts support multiple inheritance.

EVM provides four data locations for storing data:

Storage, persistent, stored throughout Ether Square

Memory, local memory of the function, non-persistent

Calldata, function input parameter, non-persistent

Call stack of stack,EVM

Rules:

Status variable: storage

Input parameter of external function: calldata

Function input parameter: memory

Function local variables:

Reference type, default to storage, but can be overridden

Value type, memory, cannot be overridden

Mapping type, pointing to external state variables

Assignments between state variables produce independent copies, that is, changes to each other are not referenced.

Storage and memory variables are assigned to each other and always produce independent copies.

Assignment between memory variables

Value type, producing an independent copy

Reference type, pointing to the same address

Since contract execution is costly, you need to be wary of looping statements.

For contracts with multiple inheritance, the order needs to be clearly specified, such as:

Contract X {} contract An is X {} contract C is A, X {}

The fallback function does not have a function name and cannot be called directly, but it can be triggered in two cases:

When no function in the contract matches the request sent by the caller

When the contract receives the ether, the fallback function needs to use payable

Because it cannot be called externally, EVM restricts it to consume a maximum of 2300 of gas. If it exceeds that, the fallback function fails. Therefore, remember to test whether the contract's fallback function exceeds this limit.

Moreover, fallback is a high incidence area of safety accidents, so necessary safety-related tests are needed.

Interfaces and abstract contracts are not much different from interfaces and abstract classes in Java. A library is a piece of reusable code that executes within the context of the contract that invokes it:

It cannot use state variables

Unable to inherit or be inherited

Cannot receive ether

After the contract throws an exception, the status is rolled back. Currently, there are three ways:

Require (expression). If the expression is false, an exception is thrown, and unused gas is returned.

Input parameters suitable for verification function

Assert (expression), same as above, but unused gas will not be returned and will all be consumed

Suitable for verifying internal status

Revert (), throwing an exception directly

5 common patterns

In view of the following characteristics of the Ethernet Square application, you need to be very careful when writing solidity code:

Execution consumes real money and silver

The contract is publicly visible, even if it is private

The contract cannot be tampered with and cannot be changed once released.

Common coding routines are:

For payments, it is preferred to "withdraw" rather than "transfer" (that is, send or transfer) to avoid receiving the contract malicious fallback function.

For payment, the CDI mode is adopted to avoid the problem of reentry. That is:

Check-> change the status of this contract-> pay.

Make good use of Modifier for access control.

Use the mapping type to save contract data, and even separate two categories for easy upgrade:

The data contract, which contains only mapping, retains the function of operating mapping, which is objectively similar to a data table.

The control contract, which contains only logical control, manipulates data through the interface of the data contract. If there is a problem with the logic, you only need to upgrade this contract and the data can still be retained.

Use agency contracts.

Finally, and the easiest way: use mature class libraries, such as OpenZeppelin.

At this point, the study of "what are the Solidity knowledge points for old programmers" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.