作者： tangc

了解solidity 最好还是自己去阅读英文的官方文档加上一些中文文档辅助。

英文文档 当前最新版本地址：https://solidity.readthedocs.io/en/v0.5.8/

一. 注释

//单行注释

/* 多行注释 */

///可以生成文档的注释   /** 可以生成文档的注释 */

二. 数据类型

1 整型

通过int/uint定义。可以设置占用空间的大小。从8位开始，8位步长，最大到256位。int8、int16、int24、uint8……

int unit默认是256位。

uint一般用来表示货币数量和时间戳。solidity目前是不支持double float的。

如：uint balace = 1 ether;  uint time = 1 hours;

整型常量需要通过 constant 修饰。

2 布尔型

bool 常量值有true false。

3. 地址

以太坊中的地址位160位，即20个字节大小。

address public owner;

4 字节

固定长度字节数以 bytes 加上数字定义。如：bytes 2 foo;

动态长度字节以 bytes数组和string定义。bytes类似byte[]，string 不提供长度和按索引访问。

bytes foo;  或者 string str = “hello”;

5 时间单位和货币单位

seconds minutes hours days weeks years 均可作为后缀，并进行相互转换。默认为秒。

wei finney szabo ether等是货币单位。

6 数组和多维数组

固定长度的数组 uint[5] x =[1,2,3,4,5];

动态数组 bytes32 [] names;

多维数组中需要指出的是 solidity中的行列和大多数编程语言是相反的。

7 映射/字典

映射的定义 mapping(_KeyType => _KeyValue)。如：mapping(string =>uint) public balance;

以太坊开发离不开geth控制台的使用。直接的交互，很容易快速和以太坊的网络进行通讯。geth控制台实现了所有web3的API和Admin的API。

启动与退出

启动 最简单的命令 ： geth console
退出输入 exit
输出日志 geth console 2 >> eth_log.log
使用 –verbosity 0 console 可以控制日记级别
连接一个geth的节点 geth attach path/ipc 或者 geth attach http://192.168.1.2:8545 或者 geth attach ws://192.168.1.2:8546

众筹你的创意

有时一个好创意需要大量的资金和集体努力。你可以要求捐赠，但捐赠者更愿意捐赠给他们更确定的项目，这样就能得到足够的支持和资金。这是一个众筹将会很理想的例子:你设定了一个目标，并在最后期限前完成。如果你错过了你的目标，这些捐赠会被返还，从而减少捐赠者的风险。由于代码是开放的和可审计的，所以不需要一个集中的、可信任的平台，因此每个人只需要支付的费用就是燃气费。

TOKENS AND DAOS

在这个例子中，我们将通过解决两个重要的问题来写一个更好的众筹:如何管理和保存奖励，以及在筹集资金后如何使用这些资金。

众筹的回报通常是由一个中心不变的数据库来处理的，该数据库可以跟踪所有捐赠者:任何错过了活动截止日期的人都无法进入，任何改变主意的捐赠者都无法离开。相反，我们将采用分散的方式，并创建一个代币来跟踪奖励，任何贡献的人都会得到一个令他们可以交易、出售或保留的代币。当给出实物奖励的时候，生产者只需要交换真实产品的代币。捐赠者可以保留他们的代币，即使这个项目没有实现它的目标，也可以作为一个纪念品。

而且，一般来说，那些在资金筹集和管理不善的情况下，资金如何使用的人也不能有任何发言权，这往往导致项目根本无法提供任何东西。在这个项目中，我们将使用一个民主的组织，它必须批准任何来自系统的资金。这通常被称为“众包”或“股东权益”，这是非常重要的，在某些情况下，代币可以是奖励本身，尤其是在一些项目中，一群人聚集在一起，建立共同的公共利益。

• If you are just testing, switch the wallet to the testnet and start mining.
• First of all, create a fixed supply token. For this example, we are going to create a supply of 100, use the name gadgets, the box emoji (📦) as a symbol and 0 decimal places. Deploy it and save the address.
• Now create a shareholder association. In this example we are going to use the address of the token we just created as the Shares Address, a minimum quorum of 10, and 1500 minutes (25 hours) as the voting time. Deploy this contract and save the address.

THE CODE

Now copy this code and let’s create the crowdsale:

pragma solidity ^0.4.16;

interface token {
    function transfer(address receiver, uint amount);
}

contract Crowdsale {
    address public beneficiary;
    uint public fundingGoal;
    uint public amountRaised;
    uint public deadline;
    uint public price;
    token public tokenReward;
    mapping(address => uint256) public balanceOf;
    bool fundingGoalReached = false;
    bool crowdsaleClosed = false;

    event GoalReached(address recipient, uint totalAmountRaised);
    event FundTransfer(address backer, uint amount, bool isContribution);

    /**
     * Constrctor function
     *
     * Setup the owner
     */
    function Crowdsale(
        address ifSuccessfulSendTo,
        uint fundingGoalInEthers,
        uint durationInMinutes,
        uint etherCostOfEachToken,
        address addressOfTokenUsedAsReward
    ) {
        beneficiary = ifSuccessfulSendTo;
        fundingGoal = fundingGoalInEthers * 1 ether;
        deadline = now + durationInMinutes * 1 minutes;
        price = etherCostOfEachToken * 1 ether;
        tokenReward = token(addressOfTokenUsedAsReward);
    }

    /**
     * Fallback function
     *
     * The function without name is the default function that is called whenever anyone sends funds to a contract
     */
    function () payable {
        require(!crowdsaleClosed);
        uint amount = msg.value;
        balanceOf[msg.sender] += amount;
        amountRaised += amount;
        tokenReward.transfer(msg.sender, amount / price);
        FundTransfer(msg.sender, amount, true);
    }

    modifier afterDeadline() { if (now >= deadline) _; }

    /**
     * Check if goal was reached
     *
     * Checks if the goal or time limit has been reached and ends the campaign
     */
    function checkGoalReached() afterDeadline {
        if (amountRaised >= fundingGoal){
            fundingGoalReached = true;
            GoalReached(beneficiary, amountRaised);
        }
        crowdsaleClosed = true;
    }


    /**
     * Withdraw the funds
     *
     * Checks to see if goal or time limit has been reached, and if so, and the funding goal was reached,
     * sends the entire amount to the beneficiary. If goal was not reached, each contributor can withdraw
     * the amount they contributed.
     */
    function safeWithdrawal() afterDeadline {
        if (!fundingGoalReached) {
            uint amount = balanceOf[msg.sender];
            balanceOf[msg.sender] = 0;
            if (amount > 0) {
                if (msg.sender.send(amount)) {
                    FundTransfer(msg.sender, amount, false);
                } else {
                    balanceOf[msg.sender] = amount;
                }
            }
        }

        if (fundingGoalReached && beneficiary == msg.sender) {
            if (beneficiary.send(amountRaised)) {
                FundTransfer(beneficiary, amountRaised, false);
            } else {
                //If we fail to send the funds to beneficiary, unlock funders balance
                fundingGoalReached = false;
            }
        }
    }
}

CODE HIGHLIGHTS

Notice that in the Crowdsale function (the one that is called upon contract creation), how the variables deadline and fundingGoal are set:

fundingGoal = fundingGoalInEthers * 1 ether;
deadline = now + durationInMinutes * 1 minutes;
price = etherCostOfEachToken * 1 ether;

Those are some of the special keywords in solidity that help you code, allowing you to evaluate some things like 1 ether == 1000 finney or 2 days == 48 hours. Inside the system all ether amounts are kept track in wei, the smallest divisible unit of ether. The code above converts the funding goal into wei by multiplying it by 1,000,000,000,000,000,000 (which is what the special keyword ether converts into). The next line creates a timestamp that is exactly X minutes away from today by also using a combination of the special keywords now and minutes. For more global keywords, check the solidity documentation on Globally available variables.

The following line will instantiate a contract at a given address:

tokenReward = token(addressOfTokenUsedAsReward);

Notice that the contract understands what a token is because we defined it earlier by starting the code with:

interface token { function transfer(address receiver, uint amount){  } }

This doesn’t fully describe how the contract works or all the functions it has, but describes only the ones this contract needs: a token is a contract with a transfer function, and we have one at this address.

HOW TO USE

Go to contracts and then deploy contract:

• Put the address of the organization you just created in the field if successful, send to.
• Put 250 ethers as the funding goal
• If you are just doing it for a test or demonstration, put the crowdsale duration as 3-10 minutes, but if you are really raising funds you can put a larger amount, like 45,000 (31 days).
• The ether cost of each token should be calculated based on how many tokens you are putting up for sale (a maximum of how many you added as “initial supply” of your token on the previous step). In this example, put 5 ethers.
• The address of the token you created should be added to the token reward address

Put a gas price, click deploy and wait for your crowdsale to be created. Once the crowdsale page is created, you now need to deposit enough rewards so it can pay the rewards back. Click the address of the crowdsale, then deposit and send 50 gadgets to the crowdsale.

I have 100 gadgets. Why not sell them all?

This is a very important point. The crowdsale we are building will be completely controlled by the token holders. This creates the danger that someone controlling 50%+1 of all the tokens will be able to send all the funds to themselves. You can try to create special code on the association contract to prevent these hostile takeovers, or you can instead have all the funds sent to a simple address. To simplify we are simply selling off half of all the gadgets: if you want to further decentralize this, split the remaining half between trusted organizations.

RAISE FUNDS

Once the crowdsale has all the necessary tokens, contributing to it is easy and you can do it from any ethereum wallet: just send funds to it. You can see the relevant code bit here:

function () {
    require(!crowdsaleClosed);
    uint amount = msg.value;
    // ...

The unnamed function is the default function executed whenever a contract receives ether. This function will automatically check if the crowdsale is active, calculate how many tokens the caller bought and send the equivalent. If the crowdsale has ended or if the contract is out of tokens the contract will throw meaning the execution will be stopped and the ether sent will be returned (but all the gas will be spent).

This has the advantage that the contract prevents falling into a situation that someone will be left without their ether or tokens. In a previous version of this contract we would also self destruct the contract after the crowdsale ended: this would mean that any transaction sent after that moment would lose their funds. By creating a fallback function that throws when the sale is over, we prevent anyone losing money.

The contract has a safeWithdrawl() function, without any parameters, that can be executed by the beneficiary to access the amount raised or by the funders to get back their funds in the case of a failed fundraise.

Extending the crowdsale

WHAT IF THE CROWDSALE OVERSHOOTS ITS TARGET?

In our code, only two things can happen: either the crowdsale reaches its target or it doesn’t. Since the token amount is limited, it means that once the goal has been reached no one else can contribute. But the history of crowdfunding is full of projects that overshoot their goals in much less time than predicted or that raised many times over the required amount.

UNLIMITED CROWDSALE

So we are going to modify our project slightly so that instead of sending a limited set of tokens, the project actually creates a new token out of thin air whenever someone sends them ether. First of all, we need to create a Mintable token.

Then modify the crowdsale to rename all mentions of transfer to mintToken:

contract token { function mintToken(address receiver, uint amount){  } }
// ...
    function () {
        // ...
        tokenReward.mintToken(msg.sender, amount / price);
        // ...
    }

Once you published the crowdsale contract, get its address and go into your Token Contract to execute a Change Ownership function. This will allow your crowdsale to call the Mint Token function as much as it wants.

Warning: This opens you to the danger of hostile takeover. At any point during the crowdsale anyone who donates more than the amount already raised will be able to control the whole pie and steal it. There are many strategies to prevent that, but implementing will be left as an exercise to the reader:

• Modify the crowdsale such that when a token is bought, also send the same quantity of tokens to the founder’s account so that they always control 50% of the project
• Modify the Organization to create a veto power to some trusted third party that could stop any hostile proposal
• Modify the token to allow a central trusted party to freeze token accounts, so as to require a verification that there isn’t any single entity controlling a majority of them

SCHEDULING A CALL

Ethereum contracts are passive, in that they can only do something once they have been activated. Fortunately there are some third party community services that provide that service for you: the Ethereum Alarm Clock is an open marketplace where anyone can receive ether to execute scheduled calls or pay ether to schedule them. This tutorial will be using the 0.6.0 version of the Alarm service. Documentation for this version available here.

First, you need to add the contract to your watchlist. Go to your Contracts tab and then Watch contract (not deploy contract): Give the name “Ethereum Alarm Clock”, use 0xe109EcB193841aF9dA3110c80FDd365D1C23Be2a as address (the icon should look like a green eyed creature) and add this code as the Json Interface:

[{"constant":false,"inputs":[{"name":"contractAddress","type":"address"},{"name":"abiSignature","type":"bytes4"},{"name":"targetBlock","type":"uint256"}],"name":"scheduleCall","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"contractAddress","type":"address"},{"name":"abiSignature","type":"bytes4"},{"name":"targetBlock","type":"uint256"},{"name":"suggestedGas","type":"uint256"},{"name":"gracePeriod","type":"uint8"}],"name":"scheduleCall","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[],"name":"getDefaultPayment","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"getDefaultFee","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[{"name":"contractAddress","type":"address"},{"name":"abiSignature","type":"bytes4"},{"name":"targetBlock","type":"uint256"},{"name":"suggestedGas","type":"uint256"}],"name":"scheduleCall","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[{"name":"callAddress","type":"address"}],"name":"getNextCallSibling","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[{"name":"callAddress","type":"address"}],"name":"isKnownCall","outputs":[{"name":"","type":"bool"}],"type":"function"},{"constant":true,"inputs":[{"name":"basePayment","type":"uint256"}],"name":"getMinimumCallCost","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[{"name":"contractAddress","type":"address"},{"name":"abiSignature","type":"bytes4"},{"name":"targetBlock","type":"uint256"},{"name":"suggestedGas","type":"uint256"},{"name":"gracePeriod","type":"uint8"},{"name":"basePayment","type":"uint256"}],"name":"scheduleCall","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[],"name":"getMinimumCallCost","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[{"name":"contractAddress","type":"address"},{"name":"abiSignature","type":"bytes4"},{"name":"targetBlock","type":"uint256"},{"name":"suggestedGas","type":"uint256"},{"name":"gracePeriod","type":"uint8"},{"name":"basePayment","type":"uint256"},{"name":"baseFee","type":"uint256"}],"name":"scheduleCall","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[{"name":"basePayment","type":"uint256"},{"name":"baseFee","type":"uint256"}],"name":"getMinimumCallCost","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"getMinimumCallGas","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"getCallWindowSize","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"blockNumber","type":"uint256"}],"name":"getNextCall","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[],"name":"getMinimumGracePeriod","outputs":[{"name":"","type":"uint256"}],"type":"function"}]

Tip: if you are on the test net, use the address 0xb8Da699d7FB01289D4EF718A55C3174971092BEf instead

Click on the green icon that you just added and then choose a function call under the Write to contract title. There will be multiple Schedule Call functions, choose the first one, that only has three fields:

• contractAddress will be the address of the deployed crowdsale contract.
• abiSignature will be 0x01cb3b20. You can figure out the signature for any function by trying to execute them but in the confirmation window, instead of typing your password, copy the code in the Data field. The function signature is the first 10 characters in bold.
• targetBlock is the block number in which you want the function to be executed, read below to calculate an estimation.

The crowdsale contract specifies a deadline using a timestamp, but the Alarm clock currently schedules calls based on block numbers. Since ethereum has a block time of approximately 17 seconds, we need to compute a block number that is going to be probabilistically past the deadline. We can do this with the formula current_block_number + duration_in_minutes * 60 / 17 + buffer where buffer is a number of blocks that is sufficiently large that you can rely on it occurring after the crowdsale deadline. For short crowdsales less than a day in duration a buffer of 200 blocks should be sufficient. For durations closer to 30 days, you should probably pick a number closer to 5,000.

You can use the following chart for rough estimates for how many blocks to add to the current block to compute the targetBlock.

• 1 hour duration (60 minutes): 212 blocks
• 1 day duration (1440 minutes): 5082 blocks
• 1 week duration (10,800 minutes): 38,117 blocks
• 1 month duration (44,640 minutes): 157,553 blocks

On the Send field, you need to send enough ether to pay the transaction fee, plus some more to pay the scheduler. Any extra money sent will be refunded, so sending at least 0.25 ether will probably keep you on the safe side.

After that, just press execute and your call will be scheduled. There are no guarantees that someone will actually execute it, so you should check back after the deadline has passed to be sure.