ARTS w04- 使用 EOS 兑换 FO

Tips

这周 EOS 有一个重大事件，FIBOS 主网上线，引起极大的关注。FIBOS 是 EOS 的一个侧链，支持用 JavaScript 开发智能合约，部署简单，极大降低了开发者的学习门槛。FIBOS 公链的代币是 FO，兑换 FO 需要写代码过程比较麻烦：

1. 生成一个 FIBOS 公私钥

   var prikey = FIBOS.modules.ecc.randomKeySync(); //私钥
   var pubkey = FIBOS.modules.ecc.privateToPublic(prikey); //公钥
   

2. 免费创建一个 FIBOS 账号

   var http = require('http');
   var httpClient = new http.Client();
   var httpServerHost = "http://tunnel.fibos.io/1.0/app/token/create";
   var account = "xxx";  //你的 FIBOS 账户名
   var pubkey = "xxx"; //你的 FIBOS 公钥
   var rep = httpClient.post(httpServerHost, {
       json: {
           account: account,
           pubkey: pubkey
       }
   }).json()
   console.log(rep);
   

3. 进行从 EOS 到 FIBOS 的跨链转账，这一步可以用 eos 钱包实现，如果没有 eos 账户要先请人帮忙注册一个（购买内存，抵押 cpu 和 net），然后充一些 eos 进去。

4. 兑换 FO

   var FIBOS = require("fibos.js");
   var config = {
       chainId: "6aa7bd33b6b45192465afa3553dedb531acaaff8928cf64b70bd4c5e49b7ec6a",
       priKey: "你的 FIBOS 私钥",
       httpEndpoint: "http://ca-rpc.fibos.io:8870",
       verbose: false,
   }
   var fibos_client = FIBOS({
       chainId: config.chainId,
       keyProvider: config.priKey,
       httpEndpoint: config.httpEndpoint,
       verbose: false,
       logger: {
           log: null,
           error: null
       }
   })
   
   let ctx = fibos_client.contractSync("eosio.token");
   var result = ctx.exchangeSync("你的 FIBOS 账户名", `10.0000 EOS@eosio`, `0.0000 FO@eosio`, `exchange EOS to FO`, {
       authorization: "你的FIBOS账户名"
   });
   console.log(result);
   

FIBOS 最大的创新是使用 bancor 协议进行 FO 的发行（被称为 IBO），用户需要用 EOS 去兑换 FO，当前兑换出来的 FO 越多，则要花费的 EOS 越多。用 bancor 发行代币需要抵押一定的保证金，杜绝了空气币项目，不用担心项目方割韭菜。FIBOS 上线可能会引来一波 IBO 项目。拭目以待。

Algorithm

输入两个字符串 haystack 和 needle, 若 needle 是 haystack 的子串，返回其第一次出现的位置。若不是，返回 -1。若 needle 为空串，返回 0

Example 1:

Input: haystack = "hello", needle = "ll"
Output: 2
Example 2:

Input: haystack = "aaaaa", needle = "bba"
Output: -1

题目很简单，代码：

class Solution:
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        if not needle:
            return 0
        
        needle_len = len(needle)
        for i in range(len(haystack)):
            if len(haystack[i:]) < len(needle):
                return -1
            if haystack[i:i+needle_len] == needle:
                return i
        
        return -1

更简单的直接调用python的查找函数，haystack.index(needle)，若是不存在会抛出异常，可以捕获异常，返回-1。

再一题，141题 Linked List Cycle ，判断一个链表是否是一个循环链表，代码：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        
        if not head:
            return False
        
        node = ListNode(0)
        while head.next:
            if head.next == node:
                return True
        
            tail =  head
            head = head.next
            tail.next = node
        
        return False

如果一个链表是循环链表，说明所有的 node.next 都不为 None，如果循环遍历，肯定是死循环，怎么跳出这个死循环？每遍历一个节点的时候，重新赋值 next，这里是 node = ListNode(0) 这样就可以断开循环了，如果有node.next 等于新赋值的node，说明有循环了。

Review

Counterfactual: Generalized State Channels on Ethereum，这篇文章介绍了以太坊的状态通道，状态通道是解决区块链扩展性问题的方案之一，文章对状态通道的解释很清晰：

State channels work by “locking up” some portion of blockchain state into a multisig contract, controlled by a defined set of participants. The state that is “locked up” is called a state deposit. For instance, this might be an amount of ether or an ERC20 token, but could also be a cryptokitty or an ENS domain name.

状态通道原理是将一部分的区块链状态锁定到一个多签名合约中，这个合约由多个参与者共同控制。之后这多个参与者的交易就可以在这个通道中进行，而不用上链，这样能实现实时转账，甚至可以没有手续费。当合约中的某个参与者要提交状态到链上时，要提交一个多签名交易，并得到其他参与者的确认之后，才能成功提交。

文章提出了一个概念：“Counterfactual instantiation”，这个词组中文不知道怎么翻译，直译是“假设的代表”。

Counterfactual instantiation means to instantiate a contract without actually deploying it on-chain.

也就是发布一个合约，这个合约实际上并没有提交到链上，但用户可以在该合约所创建的状态通道进行实时交易。Counterfactual instantiation 是通过用户在多签名钱包中签名和共享承诺来达成。当然，这个假设的合约在链上会有一个映射的合约入口，当用户要将最终的状态发布到链上时，通过这个映射的合约入口来实现。

发布这篇文章的团队有两个目标：一是通过状态通道来保护用户的隐私，因为通道中的交易在链上是不可见的。二是开发一个状态通道框架，方便开发者调用，为开发安全高效的应用提供标准套件。这个如果能实现，将会改变以太坊的 Dapp 应用生态。

Share

这周做了 The Ethernaut 上的十几道智能合约题，对于智能合约的常见安全问题做了个总结，见这里。