以太坊微支付通道原理与实现

线上直接转账需要一定的费用，如果存在大量小额交易的情况下，费用会变的难以承受，因而以太坊引入了微交易支付通道来解决这个问题。以太坊提供了一个票据支付方案，主要依赖于智能合约实现的一对多的账单系统。该账单系统大致上的执行流程如下.

• 1：账单生成，同时提供机制往账单上存入保证金。

• 2：交易发起人生成交易票据

• 3：直接将票据发送给接收人

• 4：接收人兑现票据,从合约转账(尽管某次兑现可能会失败,但是只要票据存在最终还是能够兑现).

这种交易优点在于可以在线下发送任意数量的交易，而只需要两个链上交易（存入保证金，兑现）只要存入保证金，线下通过交换票据进行任意数量的交易，避免了频繁的线上转账，节省了交易费用。

代码结构

1. .
2. ├── api.go //对外接口
3. ├── cheque.go //账单
4. ├── cheque_test.go
5. ├── contract
6. │   ├── chequebook.go //合约go语言接口
7. │   ├── chequebook.sol //合约源码
8. │   ├── code.go //合约byte码
9. │   ├── mortal.sol //合约销毁
10. │   └── owned.sol //hebe权限
11. └── gencode.go //合约byte码生成

合约层

合约自身是接收转账的，用户可以在初始化或者后来增加金额，可以通过cash方法兑现票据，转账金额都会保存在send变量上。

1. pragma solidity ^0.4.18;
3. import "./mortal.sol";
5. /// @title Chequebook for Ethereum micropayments
6. /// @author Daniel A. Nagy <daniel@ethereum.org>
7. contract chequebook is mortal {
8. // Cumulative paid amount in wei to each beneficiary
9. //已经支付的 可以控制双花,防止多次兑换票据
10. mapping (address => uint256) public sent;
12. /// @notice Overdraft event
13. event Overdraft(address deadbeat);
15. // Allow sending ether to the chequebook.
16. function() public payable{ }
18. /// @notice Cash cheque
19. ///
20. /// @param beneficiary beneficiary address
21. /// @param amount cumulative amount in wei
22. /// @param sig_v signature parameter v
23. /// @param sig_r signature parameter r
24. /// @param sig_s signature parameter s
25. /// The digital signature is calculated on the concatenated triplet of contract address, beneficiary address and cumulative amount
26. function cash(address beneficiary, uint256 amount, uint8 sig_v, bytes32 sig_r, bytes32 sig_s) public{
27. // Check if the cheque is old.
28. // Only cheques that are more recent than the last cashed one are considered.
29. require(amount > sent[beneficiary]);
30. // Check the digital signature of the cheque.
31. bytes32 hash = keccak256(address(this), beneficiary, amount);
32. require(owner == ecrecover(hash, sig_v, sig_r, sig_s));
33. // Attempt sending the difference between the cumulative amount on the cheque
34. // and the cumulative amount on the last cashed cheque to beneficiary.
35. uint256 diff = amount - sent[beneficiary];
36. if (diff <= this.balance) {
37. // update the cumulative amount before sending
38. sent[beneficiary] = amount;
39. beneficiary.transfer(diff);
40. } else {
41. // Upon failure, punish owner for writing a bounced cheque.
42. // owner.sendToDebtorsPrison();
43. Overdraft(owner);
44. // Compensate beneficiary.
45. selfdestruct(beneficiary);
46. }
47. }
48. }

支付层

账单保存了账本的位置，记账人，所有人等信

1. // Chequebook can create and sign cheques from a single contract to multiple beneficiaries.
2. // It is the outgoing payment handler for peer to peer micropayments.
3. type Chequebook struct {
4. path string // path to chequebook file
5. prvKey *ecdsa.PrivateKey // private key to sign cheque with
6. lock sync.Mutex //
7. backend Backend // blockchain API
8. quit chan bool // when closed causes autodeposit to stop
9. owner common.Address // owner address (derived from pubkey)
10. contract *contract.Chequebook // abigen binding
11. session *contract.ChequebookSession // abigen binding with Tx Opts
13. // persisted fields
14. balance *big.Int // not synced with blockchain
15. contractAddr common.Address // contract address
16. sent map[common.Address]*big.Int //tallies for beneficiaries
18. txhash string // tx hash of last deposit tx
19. threshold *big.Int // threshold that triggers autodeposit if not nil
20. buffer *big.Int // buffer to keep on top of balance for fork protection
22. log log.Logger // contextual logger with the contract address embedded
23. }

票据：合约位置,接收人,金额,签名

1. type Cheque struct {
2. Contract common.Address // address of chequebook, needed to avoid cross-contract submission
3. Beneficiary common.Address
4. Amount *big.Int // cumulative amount of all funds sent
5. Sig []byte // signature Sign(Keccak256(contract, beneficiary, amount), prvKey)
6. }

票据生成

生成一条支付记录,返回一份签名后的票据,收费这凭借这张票据从合约里面取钱.

1. // Issue creates a cheque signed by the chequebook owner's private key. The
2. // signer commits to a contract (one that they own), a beneficiary and amount.
3. func (self *Chequebook) Issue(beneficiary common.Address, amount *big.Int) (ch *Cheque, err error) {
4. defer self.lock.Unlock()
5. self.lock.Lock()
7. if amount.Sign() <= 0 {
8. return nil, fmt.Errorf("amount must be greater than zero (%v)", amount)
9. }
10. if self.balance.Cmp(amount) < 0 {
11. err = fmt.Errorf("insufficient funds to issue cheque for amount: %v. balance: %v", amount, self.balance)
12. } else {
13. var sig []byte
14. sent, found := self.sent[beneficiary]
15. if !found {
16. sent = new(big.Int)
17. self.sent[beneficiary] = sent
18. }
19. sum := new(big.Int).Set(sent)
20. sum.Add(sum, amount)
22. sig, err = crypto.Sign(sigHash(self.contractAddr, beneficiary, sum), self.prvKey)
23. if err == nil {
24. ch = &Cheque{
25. Contract: self.contractAddr,
26. Beneficiary: beneficiary,
27. Amount: sum,
28. Sig: sig,
29. }
30. sent.Set(sum)
31. self.balance.Sub(self.balance, amount) // subtract amount from balance
32. }
33. }
35. // 账单余额少于阈值,自动补充.
36. if self.threshold != nil {
37. if self.balance.Cmp(self.threshold) < 0 {
38. send := new(big.Int).Sub(self.buffer, self.balance)
39. self.deposit(send)
40. }
41. }
43. return
44. }

存储金额

1. func (self *Chequebook) Deposit(amount *big.Int) (string, error) {
2. defer self.lock.Unlock()
3. self.lock.Lock()
4. return self.deposit(amount)
5. }
7. func (self *Chequebook) deposit(amount *big.Int) (string, error) {
8. // since the amount is variable here, we do not use sessions
9. depositTransactor := bind.NewKeyedTransactor(self.prvKey)
10. depositTransactor.Value = amount
11. chbookRaw := &contract.ChequebookRaw{Contract: self.contract}
12. //转入金额
13. tx, err := chbookRaw.Transfer(depositTransactor)
14. if err != nil {
15. self.log.Warn("Failed to fund chequebook", "amount", amount, "balance", self.balance, "target", self.buffer, "err", err)
16. return "", err
17. }
18. // assume that transaction is actually successful, we add the amount to balance right away
19. self.balance.Add(self.balance, amount)
20. self.log.Trace("Deposited funds to chequebook", "amount", amount, "balance", self.balance, "target", self.buffer)
21. return tx.Hash().Hex(), nil
22. }

兑换票据

1. // Cash is a convenience method to cash any cheque.
2. func (self *Chequebook) Cash(ch *Cheque) (txhash string, err error) {
3. return ch.Cash(self.session)
4. }
6. // Cash cashes the cheque by sending an Ethereum transaction.
7. func (self *Cheque) Cash(session *contract.ChequebookSession) (string, error) {
8. v, r, s := sig2vrs(self.Sig)
9. //调用合约的cash方法 提取代币
10. tx, err := session.Cash(self.Beneficiary, self.Amount, v, r, s)
11. if err != nil {
12. return "", err
13. }
14. return tx.Hash().Hex(), nil
15. }

其他接口

OutBox：用于在电对点网络中发行票据，提供了保证金存入，票据发行，自动存入保证金等接口。

1. type Outbox struct {
2. chequeBook *Chequebook
3. beneficiary common.Address
4. }
6. // Issue creates cheque.
7. func (self *Outbox) Issue(amount *big.Int) (swap.Promise, error) {
8. return self.chequeBook.Issue(self.beneficiary, amount)
9. }
11. // AutoDeposit enables auto-deposits on the underlying chequebook.
12. func (self *Outbox) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) {
13. self.chequeBook.AutoDeposit(interval, threshold, buffer)
14. }

InBox:用于在电对点网络中票据兑换，提供了直接兑换，定时兑换，延迟兑换的接口功能。

1. // Inbox can deposit, verify and cash cheques from a single contract to a single
2. // beneficiary. It is the incoming payment handler for peer to peer micropayments.
3. type Inbox struct {
4. lock sync.Mutex
5. contract common.Address // peer's chequebook contract
6. beneficiary common.Address // local peer's receiving address
7. sender common.Address // local peer's address to send cashing tx from
8. signer *ecdsa.PublicKey // peer's public key
9. txhash string // tx hash of last cashing tx
10. session *contract.ChequebookSession // abi contract backend with tx opts
11. quit chan bool // when closed causes autocash to stop
12. maxUncashed *big.Int // threshold that triggers autocashing
13. cashed *big.Int // cumulative amount cashed
14. cheque *Cheque // last cheque, nil if none yet received
15. log log.Logger // contextual logger with the contract address embedded
16. }
18. // Cash attempts to cash the current cheque.
19. func (self *Inbox) Cash() (txhash string, err error) {
20. if self.cheque != nil {
21. txhash, err = self.cheque.Cash(self.session)
22. self.log.Trace("Cashing in chequebook cheque", "amount", self.cheque.Amount, "beneficiary", self.beneficiary)
23. self.cashed = self.cheque.Amount
24. }
25. return
26. }