On the first code

pragma solidity 0.6.4;

contract Faucet {
    
    // Accept any incoming amount
    receive() external payable {
    }

    //  The name of this function is withdraw, It receives a message called withdraw_amount、 The type is unsigned integer （uint） Parameters of 
    function withdraw(uint withdraw_amount) public {
    
        // Set the upper limit of coin withdrawal , It uses built-in Solidity function require To test a prerequisite ,
        // namely withdraw_amount Less than or equal to 100000000000000000 wei
        // If you use more withdraw_amount call withdraw function ,
        // Here require Function will cause contract execution to stop and fail due to exceptions 
        require(withdraw_amount <= 100000000000000000);

        //msg An object is an input that all contracts can access , It represents the transaction that triggers the execution of this contract .
        //sender Attribute is the address of the initiator who initiated the transaction .
        //transfer Function is a built-in function , It is used to transfer Ethereum from the contract to the transaction address that invokes the contract 
        // Send Ethereum to the sending address of the transaction message that triggers the execution of this contract .
        //transfer The function only accepts an amount parameter .
        // Put the previously defined withdraw_amount The value of this variable is passed as a parameter to withdraw function .
        msg.sender.transfer(withdraw_amount);
    }
}

compile Faucet contract

We have completed our first contract , Now you need to use Solidity The compiler the Solidity Code to EVM Bytecode , Only in this way can it be EVM Executed .
Solidity The compiler of is an independent executable program , It is usually contained in various programming frameworks , It will also be integrated in some IDE in . For the sake of simplicity , We use Remix This popular IDE.
1、 Open and install MetaMask The plug-in Chrome browser , visit Remix IDE Website of Chinese version http://remix.app.hubwiz.com/
2、 We add a new file by clicking the plus button on the left side of the toolbar , Name the new file Faucet.sol.

3、 Copy code , compiler ; Note that the version of the compiler should be consistent with that declared in the code

4、 Compile successfully , There will be one Faucet Contract name

Deploy Faucet contract

We already have a contract , And compiled it into bytecode . Now we need to put this contract “ register ” To Ethereum blockchain . We still use Ropsten Test the network to test the contract , therefore Ropsten This is the goal that we need to register the contract .
1、 First , Switch to “Run” TAB , stay “ Environmental Science ” Drop down menu , choice “ Injected Web3”. This will establish Remix IDE and MetaMask The connection between wallets , And then through MetaMask Connect to Ropsten Test network . After completing this setting , Will you be in “ Environmental Science ” In the column Ropsten word . Again , Your... Appears in the input box of account selection MetaMask Wallet address

2、Remix IDE Will build a special “creation” transaction , then MetaMask Will ask for your approval . If you are in MetaMask See in the , The transaction created by this contract does not contain ether , It's just 258 byte （ The compiled contract ）, This deal is gas need 10 gwei. Click on “SUBMIT” To approve this deal （ Register the contract on the blockchain ）.
3、 Please note that ,Faucet The contract now has its own address ,Remix Shown in “Faucet at 0x72e…c7829”（ Due to different addresses , These random letters and numbers will also be different ）. The small clipboard icon on the right allows you to copy the contract address to the clipboard , We will use this contract address later

Now we have a contract recorded on the blockchain , You can view it through the address . We are https://ropsten.etherscan.io
You can see . Click the icon on the clipboard to copy the contract address , Copy the address of the contract in the search box . You will see the history of the contract

So far, , This contract has only one transaction history ： Its own contracts create transactions . As you can see , This contract also doesn't have any ether （ The balance is zero ）. This is because we did not include any ether in the transaction that created the contract .

Recharge the contract

We can send some ether to this contract . Your clipboard should still contain the contract address （ without , From Remix Copy it again ）. open MetaMask
Like other transfer operations , send out 1 ether To the contract address .
Soon , If you refresh Etherscan Block browser , You will see a new transaction under the contract address , And the account balance is updated to 1 ether 了 .

When you send a transaction to the contract address , If you do not specify which function of the contract to call , It will call the default function . Because we added payable attribute , This function can receive Ethereum and deposit it into the contract balance . The deal triggers the contract at EVM Be executed on , And update the balance . In this way, we have finished recharging ！

Withdraw money from the contract

next , Let's try to withdraw ether from the contract . To withdraw money , We need to build a call withdraw Function transaction , And deliver withdraw_amount As a parameter . For the sake of simplicity , have access to Remix Build this deal , And then use MetaMask Send and get our approval .
return Remix Interface , stay Run Contract found on tab . Click to open the deployed contract , Marked as withdraw With field input marks uint256 withdraw_amount.

This is the contract in Remix Interface in . It allows us to build a transaction , Used to call the functions defined in the contract . Let's enter a withdraw_amount value , And then click “withdraw” Button to generate this transaction .
1、 First , Let's see withdraw_amount This parameter . We try to withdraw from the contract 0.1 ETH, This is the maximum amount allowed by the contract . Remember that all currency units in Ethereum should be used wei Let's say ？ therefore ,withdraw_amount Parameters must also use wei The format of . there 0.1 ETH, The corresponding is 100000000000000000 wei.
2、 stay Remix Click on the “withdraw” Create a currency withdrawal transaction MetaMask A trading window will pop up requesting your confirmation , Click on “SUBMIT” You can call the contract to withdraw money
3、Etherscan Show that the transaction invokes the contract withdraw function
We can see that this transaction takes the contract as the address , And it doesn't contain any ether . spending 0.1 ETH after , The balance of the contract has changed to 0.9 ETH. But it's strange , We don't see one “ External payment ” Transactions of are displayed in the contract address history .

4、 Where is this external payment transaction ？ A new area will appear in the contract address history page , be known as “Internal Txns”. Because of this 0.1 ETH The transfer is initiated by the contract , So this kind of transaction is called internal transaction （ Also known as message ）. Click on “Internal Txns” Internal transactions can be seen on the label

summary

We use Solidity I wrote a Faucet contract , And use Remix IDE Compile the contract into EVM Bytecode . We use Remix Build a deal , Then register this contract with Ropsten Testing the blockchain network . After registration , This contract has an Ethereum address , We can send Ethereum to this address . Final , We have built a system for withdraw Function call , And successfully extracted 0.1 ETH. The contract checked our request , Sent back to our calling address using internal transaction 0.1 ETH.
It seems quite simple , What we have just done is to use software to successfully realize the transfer operation of digital currency on a decentralized world computer .