精华内容
下载资源
问答
  • 3. NFT有哪些应用?4. NFT(非同质化代币)的标准参考 什么是非同质化代币(NFT) NFT是一个出现在2018年的区块链名称,其英文全称为Non-Fungible Token,翻译成中文就是:非同质化代币,具有不可分割、不可替代、...

    什么是非同质化代币(NFT)

    NFT是一个出现在2018年的区块链名称,其英文全称为Non-Fungible Token,翻译成中文就是:非同质化代币,具有不可分割、不可替代、独一无二等特点。

    fungible
    美: ['fʌndʒəbəl]
    英: ['fʌndʒɪbl]
    adj. 可代替的;【法】可互换的
    n. 【法】(偿还债务时所用的)代替物
    网络 可替代的;可取代的;可替代性

    1、什么是同质化代币?

    同质化代币,即FT(Fungible Token),相互能够替换、可接近无穷拆分的token。

    在区块链世界,很多项目都会发行自己的数字货币,这个就是代币,代替货币行驶买卖权。以太坊有代币ETH、币安有代币BNB、Omisego的代币OMG等等,这些代币的发行,都是基于一种叫ERC20的协议。那么我们可以说,凡是基于ERC20协议发行的代币,都是同质化代币,都可以进行互换。

    ERC20你可以把它想象成印钞机,凡是用这个印钞机生产出来的货币,本质基因是一样的。既然基因一样,当然可以进行互换,这就是同质化代币。

    同质化代币的好处很多,比如可以无限拆分,可以互相兑换,很方便。但是时间久了人们发现,现实生活中真正具有价值的事物是不可替代的,如一份合同、一项资质、一个独特设计的珠宝等,具有独一性。这时候,NFT非同质化代币就出现了。

    2. 什么是非同质化币?

    同质化代币的发行用的印钞机是ERC20,非同质化代币用的印钞机是ERC721。

    NFT 的关键创新之处在于提供了一种标记原生数字资产所有权的方法,就是说你在区块链上的一个资产被标记了,没有人能拿走。所以,虽然NFT叫非同质化代币,但其实人家本质上是一个技术,不是一种币。

    这个功能有什么作用?作用大大的。相信每个炒币的人都听过比特币被盗的例子,比特币存在交易所里,莫名其妙被偷了。如果别人偷了你的币卖掉,你也根本没办法。但是如果你的比特币上面都有编号,不就可以查出来了么。劫匪劫了银行的钱,你看他们敢不敢花?就因为每个人民币上都有编号,所以他们才不敢随便动。

    就以CryptoKitties(谜恋猫)此款游戏为例,游戏中的猫咪无法被彼此取代,假设小张拥有一只黄色猫咪,价值两百美金,而小花拥有一只蓝色有翅膀的猫咪,价值四百美金。
    在这里插入图片描述
    NFT最重要的特性为不可分割,一只以太猫咪不能分割交换,就只能整只交换或贩售,分割了就没有价值,当然它无法分割。而BTC或WDC可以分割,拿到的1BTC或1WDC可以切分两份,两份0.5个BTC或WDC,两份0.5个BTC或WDC还是有1个BTC或WDC的价值。

    3. NFT有哪些应用?

    NTF的应用场景很多,游戏、票务等等都是它的应用范围,具体的应用场景如下:

    • 游戏。例如,可用作游戏中的宠物,武器道具,服装和其他的物品。这类玩法许多读者想必并不陌生,2018年红极一时的加密猫,用的就是NFT技术,他们给每个猫进行特殊的标记编号,让它成为独一无二的猫。
    • 知识产权领域。NFT 可以代表一幅画,一首歌,一项专利,一段影片,一张照片,或者其他的知识产权。在这个领域,NFT起到的是专利局的作用。帮助每一个独一无二的东西进行版权登记,帮助其识别专利。
    • 实体资产。 房屋等不动产等其他的实物资产,可以用NFT来表示进行代币化。可以用作资产的流通等金融市场。
    • 记录和身份证明。NFT 也可以用来验证身份和出生证明,驾照,学历证书等方面。这些可以用数字形式进行安全保存,而防止被滥用或篡改。
    • 金融文件。发票,订单,保险,账单等。可以转变为 NFT,进行交易。
    • 票务。演唱会门票、电影票、话剧票等等,都可以用NFT来标记。所有的票都一样,但是座位号不同。

    4. NFT(非同质化代币)的标准

    ERC721

    它最初由CryptoKitties创造,也是代表非同质化数字资产的第一个标准。ERC721是可继承的Solidity智能合约标准。人们可以轻松地从OpenZeppelin库中继承,并将其用于编程基于NFT的项目。

    ERC1155

    它最早由Enjin提出。它使人们能够实现半同质化的代币。ERC1155允许拥有独特资产种类,而非拥有独特资产。**这些资产与ID相连接。**例如,一个ID可以有20个名为“Swords”的资产,而另一个ID可以有30个名为“Guns”的资产。

    元数据

    **元数据用于定义单个代币的唯一特征。**以加密猫为例,每只加密猫都有不同的颜色、形状、名称等。元数据通常以JSON形式表现

    链上

    在这种情况下,每个NFT都与各自的元数据链接,并存储在区块链中。最大的缺点是以太坊中的存储空间有限。

    链下

    在这种情况下,元数据存储在中心化系统(如AWS)或去中心化网络(如IPFS)中,并通过智能合约中的tokenURI参数链接到它们各自的NFT。

    参考

    NFT概念究竟是怎么回事
    参考URL: https://www.bishijie.com/shendu/134856.html
    NFT是什么?一文读懂NFT的观点
    参考URL: http://www.qingsong123.com/article/409069.html
    怎么理解NFT?一篇文章搞懂NFT的概念、应用和前景
    参考URL: https://www.playbtc.cn/rumen/1449.html

    展开全文
  • Uniswap有哪些特色呢,请见下文: 1.易于使用 在Uniswap交易所买卖代币时,您只需要确定要出售的货币,购买的货币以及购买的数量即可。 或出售。 多少钱,按交换发送交易,您就可以在交易链上之后立即得到您...

    Uniswap有哪些特色呢,请见下文:

     

     1.易于使用

     

    在Uniswap交易所买卖代币时,您只需要确定要出售的货币,购买的货币以及购买的数量即可。 或出售。 多少钱,按交换发送交易,您就可以在交易链上之后立即得到您应得的代币。  

    即使将代币A交换为代币B,Uniswap也只需发送一次交易即可完成交换。 在其他交易所中,可能需要发送两次交易(第一个交易是将代币A交换为中间货币(例如ETH,DAI),然后将第二笔交易发送给代币B)以完成交易。  

     

    注意:实际上,Uniswap还将代币A更改为ETH,然后更改为代币B,但是这使这两个操作在同一事务中发生。  

     

     

     

     

    1. gas利用率较高

     Uniswap交易消耗的gas量在以太坊上的几个主流交易所中最低,这意味着Uniswap交易要支付的矿工费用最少。  

     

    这主要是由于其相对简单的做市机制:

     

     Uniswap不使用挂单组合机制来完成交易,而是根据中保留的资金量来计算当前交易价格。 合约,并在发生交易时立即从合约储备金中提取用户的应付款并转给用户。  

     

    1.  抗审查性

    审查阻力反映在Uniswap列出新代币的阈值中:

    没有阈值,任何用户都可以在Unisawp上列出任何代币。  

    即使在许多去中心化交易所中,这一点也是罕见的。 尽管大多数分散式交易所不会像集中式交易所那样向您收取上市费用,但它们仍必须申请上市。通过审核后,运营团队将允许您在其交易所上交易您的代币。 将其放在架子上后,没有人可以将其从架子上下架。 但这也将使市场充斥各种代币。  

     

     4.零抽租

    在Uniswap的合约设计中,没有人享有任何特权,并且开发团队不会从交易中收取费用。 但这并不意味着Uniswap上的交易不收取任何手续费。  

     

    首先,您需要为将交易打包到以太坊区块链中支付一笔gas费。 这笔钱与交易金额无关。 根据最近的货币价格和网络拥塞程度估算,大约为$ 0.05〜$ 0.5。 费用可以在一分钟内在链上进行交易。  

     

    其次,Uniswap将对每笔ETH⇄代币交易收取0.3%的费用(Token⇄代币交易将收取两次,总计0.5991%)此费用称为流动性提供者费用(流动性提供者费用),将被支付 流动性提供者。

     

    展开全文
  • USDT的中文译名为“泰达币”,由香港Tether公司基于美元而发行的一种加密虚拟...作为比特币期货的最大交易平台bitfinex宣称:严格遵守1:1的准备金保证,即每发行1枚USDT代币,其银行帐户都会1美元的资金保障。在合规

    USDT的中文译名为“泰达币”,由香港Tether公司基于美元而发行的一种加密虚拟货币,如果之前做过比特币或者以太坊等项目的朋友应该不会对其感到陌生。其起源于2014年,发行和交易使用的是Omni(原Mastercoin)协议,而Omni币可以说是市面上的第一个基于比特币区块链的2.0币种。所以USDT可以看成与比特币类似的代币,人们能够通过钱包转移、贮存和消费。
    作为比特币期货的最大交易平台bitfinex宣称:严格遵守1:1的准备金保证,即每发行1枚USDT代币,其银行帐户都会有1美元的资金保障。在合规方面,所有涉及到法币的操作,都要求用户完成KYC认证。

    从上文我们知道,usdt是合规的,那么其为什么如此火呢?
    2018年开始,全球爆发经济危机,金融行业遭遇多次滑铁卢,就连稳定的外汇市场也多次爆发黑天鹅事件,我国经济紧缩,各企业集团陆续裁人。在比特币期货市场中,比特币价格成跳水式下降,即便出现短暂的小牛市,人们也像坐电梯一样,上去又下来了。但是usdt却逆势狂涨,成为虚拟货币中比较坚挺的币种。

    usdt场外交易平台作为一种新兴商业模式,是如何运作的?
    Usdt跑分平台的难点在于需要与多方平台进行数据对接。我们都知道,在数据对接的过程中,重点是需要保护数据的安全传输,因此usdt跑分平台采用了最前沿的区块链技术,重要信息本地化存储,独特的硬件加密方式,并引进助记词、密码签名等,通过强化衍生。
    其商业模式相对简单: 承兑在平台挂上一定的USDT并发布接单,平台为其自动匹配买家,买家通过平台的对接,将人民币打给个人承兑商(usdt大户持币者),平台确认人民币到账,将币放行支付方(担保者),确认到账后结算商户,然后通过API数据接口回调,给客户入金。项目了解 elvis_OTC魏鑫这时承兑商即可获利一定比例的点差。

    展开全文
  • 3Mist 有哪些依赖 4如何安装 Mist 1安装 Mist 依赖工具包 2安装 Mist 3启动 Mist连接到 Geth 5使用 Mist 部署一个简单的智能合约 6改善代币 1如何部署 7高级版的代币功能 1去中心化的管理者 2挖矿 3冻结资产 4自动...

    目录

    1、什么是 Mist

      Mist是以太坊官方的在线钱包管理工具。通过 Mist 我们可以很方便的连接上我们的私有网络,从而更好的开发、调试、测试我们的智能合约。既可以连接生产网络、测试网络,更加可以通过设置参数的方式,连接我们自己的私有网络。

      Mist 在通过 geth.ipc 文件连接后,就和 Geth 所建立的网络完全契合在一起了,在 Mist 上部署的合约,实际上也就是部署在了 Geth 网络上。Geth 网络上新建账号,也可以在 Mist 这个工具上看到。

      通过 Mist,我们向大家更详细的讲解了以太坊的核心概念,包括:区块、Transaction、Gas、账户、合约、合约中的构造函数,变量以及方法。

    2、Mist 在哪里下载?

      开发版的 Mist 在这里下载:https://github.com/ethereum/mist

      如果要在生产环境上操作,可以直接在以太坊官网下载钱包工具:https://ethereum.org/

    3、Mist 有哪些依赖?

      需要有以下组件:

    • Node.js v7.x (use the prefered installation method for your OS)
    • Meteor javascript app framework
    • Yarn package manager
    • Electron v1.7.9 cross platform desktop app framework
    • Gulp build and automation system

    4、如何安装 Mist?

      在安装 Mist 前,要先安装依赖的工具包。
      

    4.1、安装 Mist 依赖工具包

    ➜ /Users/lion >curl https://install.meteor.com/
    ➜ /Users/lion >brew install yarn
    ➜ /Users/lion >yarn global add electron@1.7.9
    ➜ /Users/lion >yarn global add gulp

    yarn其他平台的安装方法,可以参考:https://yarnpkg.com/zh-Hans/docs/install

    4.2、安装 Mist

    ➜ /Users/lion/my_project/_eth >git clone https://github.com/ethereum/mist.git
    ➜ /Users/lion/my_project/_eth >cd mist
    ➜ /Users/lion/my_project/_eth/mist git:(develop) >git checkout v0.9.2
    ➜ /Users/lion/my_project/_eth/mist git:(369713b) >yarn

    4.3、启动 Mist,连接到 Geth

      新开一个窗口,用以下命令运行 Mist 的后台程序:

    ➜ /Users/lion/my_project/_eth/mist git:(369713b) >cd interface
    ➜ /Users/lion/my_project/_eth/mist/interface git:(369713b) >meteor --no-release-check
    [[[[[ ~/my_project/_eth/mist/interface ]]]]]
    
    => Started proxy.
    => Started MongoDB.
    => Started your app.
    
    => App running at: http://localhost:3000/
    => Client modified -- refreshing

    第一次运行会慢一些,会启动proxy、MongoDB等程序,同时下载一些依赖组件

      
      在启动 Mist 之前,我们要先启动 Geth,参考:使用 Go-Ethereum 1.7.2搭建以太坊私有链

      我们启用以太坊私有链以后,在 ./chain 目录上会创建私有链的一些数据,里面有一个 geth.ipc 文件。

    ➜ /Users/lion/my_project/_eth/test >ll chain
    total 88
    drwxr-xr-x  7 lion  staff    224 Oct 24 12:21 geth
    srw-------  1 lion  staff      0 Oct 24 12:24 geth.ipc
    -rw-------  1 lion  staff  43213 Oct 24 12:08 history
    drwx------  4 lion  staff    128 Oct 22 14:57 keystore

      
      在原来的窗口中运行以下命令,用 Mist 连接我们用 Geth 启动的私有链:

    ➜ /Users/lion/my_project/_eth/mist git:(369713b) >yarn dev:electron --rpc /Users/lion/my_project/_eth/test/chain/geth.ipc

    如果正常交易以太坊的以太币,可以在官网直接下载以太坊钱包使用:https://ethereum.org/

      
      如果在另一台机器是使用RPC方式运行,也可以使用下面的方法连接到 Geth

    ➜ /Users/lion/my_project/_eth/mist git:(369713b) >yarn dev:electron --rpc http://localhost:8545

      
      运行完以后,会打开一个比较像App的网页,如下图:

    mshk.top

    在之前的文章中我们创建的帐户,经过 Mist 连接后,也可以在可视化的界面中看到

      
      在 Mist 的界面中,点击发送,可以从一个帐户地址,向另一个帐户地址,转移以太币。

    5、使用 Mist 部署一个简单的智能合约

      在 Mist 上点击右侧的合约。首先要选择一个帐户来生成合约,用于支付部署合约的费用,以后是谁调用谁来支付费用。(如果在公有链上部署智能合约,需要花费一定的以太币)。

      下面是一个最简单的合约代码,主要介绍可以看注释:  

    pragma solidity 0.4.16;
    
    /**
     * @title 基础版的代币合约
     */
    contract token {
        /* 公共变量 */
        string public standard = 'https://mshk.top';
    
        /*记录所有余额的映射*/
        mapping (address => uint256) public balanceOf;
    
        /* 初始化合约,并且把初始的所有代币都给这合约的创建者
         * @param initialSupply 代币的总数
         */
        function token(uint256 initialSupply) {
            //给指定帐户初始化代币总量,初始化用于奖励合约创建者
            balanceOf[msg.sender] = initialSupply;
        }
    
        /**
         * 私有方法从一个帐户发送给另一个帐户代币
         * @param  _from address 发送代币的地址
         * @param  _to address 接受代币的地址
         * @param  _value uint256 接受代币的数量
         */
        function _transfer(address _from, address _to, uint256 _value) internal {
    
          //避免转帐的地址是0x0
          require(_to != 0x0);
    
          //检查发送者是否拥有足够余额
          require(balanceOf[_from] >= _value);
    
          //检查是否溢出
          require(balanceOf[_to] + _value > balanceOf[_to]);
    
          //保存数据用于后面的判断
          uint previousBalances = balanceOf[_from] + balanceOf[_to];
    
          //从发送者减掉发送额
          balanceOf[_from] -= _value;
    
          //给接收者加上相同的量
          balanceOf[_to] += _value;
    
          //判断买、卖双方的数据是否和转换前一致
          assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
    
        }
    
        /**
         * 从主帐户合约调用者发送给别人代币
         * @param  _to address 接受代币的地址
         * @param  _value uint256 接受代币的数量
         */
        function transfer(address _to, uint256 _value) public {
            _transfer(msg.sender, _to, _value);
        }
    }

      
      接下来我们将上面的合约代码,通过Mist部署到我们的私有链的。

      首先如下图中,点击合约->部署新合约

    mshk.top

      
      然后如下面的两张图,选择创建合约的帐户,将上面的代码贴到SOLIDITY合约原始代码处,在右侧选择要部署的合约token,在token的下面Initial Supply处,输入我们要初始化的金额5000用于奖励合约创建者,然后在页面的最下面,点击部署,的弹出的层中,输入创建合约这个帐号的密码,输入正确以后,合约创建成功。

    mshk.top

    mshk.top

      
      创建一个合约以后,再点击 Mist 右侧的合约,然后在 定制化合约 的下面,可以看到我们刚刚创建的合约 TOKEN ,如下图:

    mshk.top

    注意,在合约下面也有一串0x开头的地址,这个就相当于一个钱包的地址。在以太坊中,合约也相当于一个帐户

      
      点击 TOKEN ,进入到合约里。在下面的 Balance Of 处,输入刚才创建合约帐户的地址0xa18e688326ab13b6147ce3ca2213db143a4ec2ee,可以看到是有5000个代币在里面,如下图:

    mshk.top

      
      在代币创建的时候,初始值我们设置的是5000,所以只有创建帐户的地址有代币,而输入其他帐户的地址,如0xc81896af13449a82f22699311df4ec4b48c07718,是没有值的。

      接下来,我们向0xc81896af13449a82f22699311df4ec4b48c07718这个帐户地址,转入一些代币。点击右侧选择函数->选择Transfer,在_to中输入0xc81896af13449a82f22699311df4ec4b48c07718,在_value中输入500,然后点击执行,在弹出的层中输入调用合约帐户的密码,确认操作。

    mshk.top

    mshk.top

    我们能够看到实际调用合约的过程中,会花费一定的gasgas和以太币会根据区块的算力有一个计算公式,gas一般用于奖励给挖矿者

      
      在 transfer 方法中,我们设定了,只有合约的调用者msg.sender才能向指定地址转移代币。

    /**
     * 从主帐户合约调用者发送给别人代币
     * @param  _to address 接受代币的地址
     * @param  _value uint256 接受代币的数量
     */
    function transfer(address _to, uint256 _value) public {
        _transfer(msg.sender, _to, _value);
    }

      
      这时,再次进入合约,在Balance Of处,输入两个帐户的地址,可以看到,余额都发生的变化,如下图:

    mshk.top

    6、改善代币

      通过上面的操作,我们已经可以将合约代码,通过 Mist 部署到我们创建的私有链中,同样如果部署到生产环境,只需要连上以太坊的网络,同样的方法也可以将你的合约,部署到生产环境中,不过要根据代码的大小,花费一些以太币。

      实际使用过程中,交易的过程,需要通知到客户端,并且记录到区块中,我们可以使用event事件来指定,如下代码进行声明:

    //在区块链上创建一个事件,用以通知客户端
    event Transfer(address indexed from, address indexed to, uint256 value);

      
      设置一些代币的基本信息

    /* 公共变量 */
    string public standard = 'https://mshk.top';
    string public name; //代币名称
    string public symbol; //代币符号比如'$'
    uint8 public decimals = 18;  //代币单位,展示的小数点后面多少个0,和以太币一样后面是是18个0
    uint256 public totalSupply; //代币总量

      
      某些特定的场景中,不允许某个帐户花费超过指定的上限,避免大额支出,我们可以添加一个 approve 方法,来设置一个允许支出最大金额的列表。

    mapping (address => mapping (address => uint256)) public allowance;
    
    /**
     * 设置帐户允许支付的最大金额
     *
     * 一般在智能合约的时候,避免支付过多,造成风险
     *
     * @param _spender 帐户地址
     * @param _value 金额
     */
    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        return true;
    }

      
      同样在 solidity 中,合约之间也可以相互调用,我们可以增加一个 approveAndCall 方法,用于在设置帐户最大支出金额后,可以做一些其他操作。

    
    interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
    
    /**
     * 设置帐户允许支付的最大金额
     *
     * 一般在智能合约的时候,避免支付过多,造成风险
     *
     * @param _spender 帐户地址
     * @param _value 金额
     */
    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        return true;
    }
    
    /**
     * 设置帐户允许支付的最大金额
     *
     * 一般在智能合约的时候,避免支付过多,造成风险,加入时间参数,可以在 tokenRecipient 中做其他操作
     *
     * @param _spender 帐户地址
     * @param _value 金额
     * @param _extraData 操作的时间
     */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            spender.receiveApproval(msg.sender, _value, this, _extraData);
            return true;
        }
    }

      
      我们可以增加一个 burn 方法,用于管理员减去指定帐户的指定金额。进行该方法操作时,通知客户端记录到区块链中。

    
    //减去用户余额事件
    event Burn(address indexed from, uint256 value);  
    
    /**
     * 减少代币调用者的余额
     *
     * 操作以后是不可逆的
     *
     * @param _value 要删除的数量
     */
    function burn(uint256 _value) public returns (bool success) {
        //检查帐户余额是否大于要减去的值
        require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
    
        //给指定帐户减去余额
        balanceOf[msg.sender] -= _value;
    
        //代币问题做相应扣除
        totalSupply -= _value;
    
        Burn(msg.sender, _value);
        return true;
    }
    
    /**
     * 删除帐户的余额(含其他帐户)
     *
     * 删除以后是不可逆的
     *
     * @param _from 要操作的帐户地址
     * @param _value 要减去的数量
     */
    function burnFrom(address _from, uint256 _value) public returns (bool success) {
    
        //检查帐户余额是否大于要减去的值
        require(balanceOf[_from] >= _value);
    
        //检查 其他帐户 的余额是否够使用
        require(_value <= allowance[_from][msg.sender]);
    
        //减掉代币
        balanceOf[_from] -= _value;
        allowance[_from][msg.sender] -= _value;
    
        //更新总量
        totalSupply -= _value;
        Burn(_from, _value);
        return true;
    }

      
      完整的代码如下:

    pragma solidity 0.4.16;
    
    interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
    
    
    /**
     * @title 基础版的代币合约
     */
    contract token {
        /* 公共变量 */
        string public standard = 'https://mshk.top';
        string public name; //代币名称
        string public symbol; //代币符号比如'$'
        uint8 public decimals = 18;  //代币单位,展示的小数点后面多少个0,和以太币一样后面是是18个0
        uint256 public totalSupply; //代币总量
    
        /*记录所有余额的映射*/
        mapping (address => uint256) public balanceOf;
        mapping (address => mapping (address => uint256)) public allowance;
    
        /* 在区块链上创建一个事件,用以通知客户端*/
        event Transfer(address indexed from, address indexed to, uint256 value);  //转帐通知事件
        event Burn(address indexed from, uint256 value);  //减去用户余额事件
    
        /* 初始化合约,并且把初始的所有代币都给这合约的创建者
         * @param initialSupply 代币的总数
         * @param tokenName 代币名称
         * @param tokenSymbol 代币符号
         */
        function token(uint256 initialSupply, string tokenName, string tokenSymbol) {
    
            //初始化总量
            totalSupply = initialSupply * 10 ** uint256(decimals);    //以太币是10^18,后面18个0,所以默认decimals是18
    
            //给指定帐户初始化代币总量,初始化用于奖励合约创建者
            balanceOf[msg.sender] = totalSupply;
    
            name = tokenName;
            symbol = tokenSymbol;
    
        }
    
    
        /**
         * 私有方法从一个帐户发送给另一个帐户代币
         * @param  _from address 发送代币的地址
         * @param  _to address 接受代币的地址
         * @param  _value uint256 接受代币的数量
         */
        function _transfer(address _from, address _to, uint256 _value) internal {
    
          //避免转帐的地址是0x0
          require(_to != 0x0);
    
          //检查发送者是否拥有足够余额
          require(balanceOf[_from] >= _value);
    
          //检查是否溢出
          require(balanceOf[_to] + _value > balanceOf[_to]);
    
          //保存数据用于后面的判断
          uint previousBalances = balanceOf[_from] + balanceOf[_to];
    
          //从发送者减掉发送额
          balanceOf[_from] -= _value;
    
          //给接收者加上相同的量
          balanceOf[_to] += _value;
    
          //通知任何监听该交易的客户端
          Transfer(_from, _to, _value);
    
          //判断买、卖双方的数据是否和转换前一致
          assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
    
        }
    
        /**
         * 从主帐户合约调用者发送给别人代币
         * @param  _to address 接受代币的地址
         * @param  _value uint256 接受代币的数量
         */
        function transfer(address _to, uint256 _value) public {
            _transfer(msg.sender, _to, _value);
        }
    
        /**
         * 从某个指定的帐户中,向另一个帐户发送代币
         *
         * 调用过程,会检查设置的允许最大交易额
         *
         * @param  _from address 发送者地址
         * @param  _to address 接受者地址
         * @param  _value uint256 要转移的代币数量
         * @return success        是否交易成功
         */
        function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
            //检查发送者是否拥有足够余额
            require(_value <= allowance[_from][msg.sender]);   // Check allowance
    
            allowance[_from][msg.sender] -= _value;
    
            _transfer(_from, _to, _value);
    
            return true;
        }
    
        /**
         * 设置帐户允许支付的最大金额
         *
         * 一般在智能合约的时候,避免支付过多,造成风险
         *
         * @param _spender 帐户地址
         * @param _value 金额
         */
        function approve(address _spender, uint256 _value) public returns (bool success) {
            allowance[msg.sender][_spender] = _value;
            return true;
        }
    
        /**
         * 设置帐户允许支付的最大金额
         *
         * 一般在智能合约的时候,避免支付过多,造成风险,加入时间参数,可以在 tokenRecipient 中做其他操作
         *
         * @param _spender 帐户地址
         * @param _value 金额
         * @param _extraData 操作的时间
         */
        function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
            tokenRecipient spender = tokenRecipient(_spender);
            if (approve(_spender, _value)) {
                spender.receiveApproval(msg.sender, _value, this, _extraData);
                return true;
            }
        }
    
        /**
         * 减少代币调用者的余额
         *
         * 操作以后是不可逆的
         *
         * @param _value 要删除的数量
         */
        function burn(uint256 _value) public returns (bool success) {
            //检查帐户余额是否大于要减去的值
            require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
    
            //给指定帐户减去余额
            balanceOf[msg.sender] -= _value;
    
            //代币问题做相应扣除
            totalSupply -= _value;
    
            Burn(msg.sender, _value);
            return true;
        }
    
        /**
         * 删除帐户的余额(含其他帐户)
         *
         * 删除以后是不可逆的
         *
         * @param _from 要操作的帐户地址
         * @param _value 要减去的数量
         */
        function burnFrom(address _from, uint256 _value) public returns (bool success) {
    
            //检查帐户余额是否大于要减去的值
            require(balanceOf[_from] >= _value);
    
            //检查 其他帐户 的余额是否够使用
            require(_value <= allowance[_from][msg.sender]);
    
            //减掉代币
            balanceOf[_from] -= _value;
            allowance[_from][msg.sender] -= _value;
    
            //更新总量
            totalSupply -= _value;
            Burn(_from, _value);
            return true;
        }
    
    }

    6.1、如何部署

      如上面的部署中,我们将完整的代码,贴到 Mistsolidity合约原始代码 处,在右侧选择 tokenInitial Supply 输入初始金额5000Token name 输入我们的代币名称 陌上花开Token symbol 代币符号我们输入 $$,然后点击 部署,输入部署帐户的密码。

    mshk.top

      
      部署合约以后,我们能够在合约页面看到刚才创建的合约。

    mshk.top

      
      点击合约名称,可以看到合约的一些基本信息,以及合约和操作函数

    mshk.top

      
      我们能够在 Mist 上方的 钱包 中的主帐号这里看到有个小图标,说明主帐户已经有了代币,其他帐户是没有这个图标的

    mshk.top

      
      点击进入主帐号以后,我们就可以看到主帐户已经拥有的代币和以太币的数量,因为我们是参考以太币进行设置,最小单位是wei,所以小数点后面有18个0。

    mshk.top

      
      接下来,我们向另一个帐户发送一些 陌上花开 币,点击 Mist 上方的发送,输入发送的帐户地址,输入数量 500,选择发送的是 陌上花开 币,点击发送,如下图

    mshk.top

      
      再次回到钱包中,我们可以看到,另一个帐户也有了一个代币的图标,说明代币已经转入成功。

    mshk.top

      
      现在你拥有了自己的代币,也可以做转入转出操作。可以被用于价值交换,或者工作时间追踪或者其他项目。

    7、高级版的代币功能

      一般的代币可以不设置管理者,就是所谓的去中心化。实际使用过程中,可能需要给予挖矿等功能,让别人能够购买你的代币,那么我们就需要设置一个帐户地址做为这个代币合约的管理者。

    **
     * owned 是一个管理者
     */
    contract owned {
        address public owner;
    
        /**
         * 初台化构造函数
         */
        function owned() {
            owner = msg.sender;
        }
    
        /**
         * 判断当前合约调用者是否是管理员
         */
        modifier onlyOwner {
            require (msg.sender == owner);
            _;
        }
    
        /**
         * 指派一个新的管理员
         * @param  newOwner address 新的管理员帐户地址
         */
        function transferOwnership(address newOwner) onlyOwner {
            owner = newOwner;
        }
    }

      
      上面的代码是一个非常简单的合约,我们可以在后面的代码中,使用 继承 来实现后续的功能。

    /**
     * @title 高级版代币
     * 增加冻结用户、挖矿、根据指定汇率购买(售出)代币价格的功能
     */
    contract MyAdvancedToken is owned{}

      在 MyAdvancedToken 的所有方法中,可以使用 owned 的变量 ownermodifier onlyOwner

    7.1、去中心化的管理者

      我们也可以在构造函数中设置是否需要一个去中心化的管理者。

    /*初始化合约,并且把初始的所有的令牌都给这合约的创建者
     * @param initialSupply 所有币的总数
     * @param tokenName 代币名称
     * @param tokenSymbol 代币符号
     * @param centralMinter 是否指定其他帐户为合约所有者,为0是去中心化
     */
    function MyAdvancedToken(
      uint256 initialSupply,
      string tokenName,
      string tokenSymbol,
      address centralMinter
    )  {
        //设置合约的管理者
        if(centralMinter != 0 ) owner = centralMinter;
    }

    7.2、挖矿

      有的时候需要更多的代币流通,可以增加 mintToken 方法,创造更多的代币。

    /**
     * 合约拥有者,可以为指定帐户创造一些代币
     * @param  target address 帐户地址
     * @param  mintedAmount uint256 增加的金额(单位是wei)
     */
    function mintToken(address target, uint256 mintedAmount) onlyOwner {
    
        //给指定地址增加代币,同时总量也相加
        balanceOf[target] += mintedAmount;
        totalSupply += mintedAmount;
    }

      
      在方法的最后有一个 onlyOwner,说明 mintToken 是继承了 onlyOwner方法,会先调用 modifier onlyOwner 方法,然后将 mintToken 方法的内容,插入到下划线 _ 处调用。

    7.3、冻结资产

      有的场景中,某些用户违反了规定,需要冻结/解冻帐户,不想让他使用已经拥有的代币.可以增加以下代码来控制:

    //是否冻结帐户的列表
    mapping (address => bool) public frozenAccount;
    
    //定义一个事件,当有资产被冻结的时候,通知正在监听事件的客户端
    event FrozenFunds(address target, bool frozen);
    
    /**
     * 增加冻结帐户名称
     *
     * 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
     *
     * @param  target address 帐户地址
     * @param  freeze bool    是否冻结
     */
    function freezeAccount(address target, bool freeze) onlyOwner {
        frozenAccount[target] = freeze;
        FrozenFunds(target, freeze);
    }

    7.4、自动交易

      到了现在,代币的功能很完善,大家也相信你的代币是有价值的,但你想要使用以太币 ether 或者其他代币来购买,让代币市场化,可以真实的交易,我们可以设置一个价格

    //卖出的汇率,一个代币,可以卖出多少个以太币,单位是wei
    uint256 public sellPrice;
    
    //买入的汇率,1个以太币,可以买几个代币
    uint256 public buyPrice;
    
    /**
     * 设置买卖价格
     *
     * 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格,也可以在这里设置
     *
     * @param newSellPrice 新的卖出价格
     * @param newBuyPrice 新的买入价格
     */
    function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
        sellPrice = newSellPrice;
        buyPrice = newBuyPrice;
    }

      
      然后增加买、卖的方法,每一次的交易,都会消耗掉一定的 ether。在 Solidity 0.4.0 之后,要接收 ether 的函数都要加一个 payable 属性,如果你开放的合约,需要别人转钱给你,就需要加 payable

      下面的方法,不会增加代币,只是改变调用合约者的代币数量,买、卖的价格单位不是 ether,而是 wei,这是以太币中最小的单位(就像美元里的美分,比特币里的聪)。1 ether = 1000000000000000000 wei。因此使用 ether 设置价格的时候,在最后加18个0。

      当创建合约的时候,发送足够多的 ether 作为代币的背书,否则你的合约就是破产的,你的用户就不能够卖掉他们的代币。

    /**
     * 使用以太币购买代币
     */
    function buy() payable public {
      uint amount = msg.value / buyPrice;
    
      _transfer(this, msg.sender, amount);
    }
    
    /**
     * @dev 卖出代币
     * @return 要卖出的数量(单位是wei)
     */
    function sell(uint256 amount) public {
    
        //检查合约的余额是否充足
        require(this.balance >= amount * sellPrice);
    
        _transfer(msg.sender, this, amount);
    
        msg.sender.transfer(amount * sellPrice);
    }

    7.5、全部代码

      把所有的特性加上,完整的代码如下:

    pragma solidity 0.4.16;
    
    interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
    
    /**
     * owned 是一个管理者
     */
    contract owned {
        address public owner;
    
        /**
         * 初台化构造函数
         */
        function owned() {
            owner = msg.sender;
        }
    
        /**
         * 判断当前合约调用者是否是管理员
         */
        modifier onlyOwner {
            require (msg.sender == owner);
            _;
        }
    
        /**
         * 指派一个新的管理员
         * @param  newOwner address 新的管理员帐户地址
         */
        function transferOwnership(address newOwner) onlyOwner {
            owner = newOwner;
        }
    }
    
    /**
     * @title 基础版的代币合约
     */
    contract token {
        /* 公共变量 */
        string public standard = 'https://mshk.top';
        string public name; //代币名称
        string public symbol; //代币符号比如'$'
        uint8 public decimals = 18;  //代币单位,展示的小数点后面多少个0,和以太币一样后面是是18个0
        uint256 public totalSupply; //代币总量
    
        /*记录所有余额的映射*/
        mapping (address => uint256) public balanceOf;
        mapping (address => mapping (address => uint256)) public allowance;
    
        /* 在区块链上创建一个事件,用以通知客户端*/
        event Transfer(address indexed from, address indexed to, uint256 value);  //转帐通知事件
        event Burn(address indexed from, uint256 value);  //减去用户余额事件
    
        /* 初始化合约,并且把初始的所有代币都给这合约的创建者
         * @param initialSupply 代币的总数
         * @param tokenName 代币名称
         * @param tokenSymbol 代币符号
         */
        function token(uint256 initialSupply, string tokenName, string tokenSymbol) {
    
            //初始化总量
            totalSupply = initialSupply * 10 ** uint256(decimals);    //以太币是10^18,后面18个0,所以默认decimals是18
    
            //给指定帐户初始化代币总量,初始化用于奖励合约创建者
            //balanceOf[msg.sender] = totalSupply;
            balanceOf[this] = totalSupply;
    
            name = tokenName;
            symbol = tokenSymbol;
    
        }
    
    
        /**
         * 私有方法从一个帐户发送给另一个帐户代币
         * @param  _from address 发送代币的地址
         * @param  _to address 接受代币的地址
         * @param  _value uint256 接受代币的数量
         */
        function _transfer(address _from, address _to, uint256 _value) internal {
    
          //避免转帐的地址是0x0
          require(_to != 0x0);
    
          //检查发送者是否拥有足够余额
          require(balanceOf[_from] >= _value);
    
          //检查是否溢出
          require(balanceOf[_to] + _value > balanceOf[_to]);
    
          //保存数据用于后面的判断
          uint previousBalances = balanceOf[_from] + balanceOf[_to];
    
          //从发送者减掉发送额
          balanceOf[_from] -= _value;
    
          //给接收者加上相同的量
          balanceOf[_to] += _value;
    
          //通知任何监听该交易的客户端
          Transfer(_from, _to, _value);
    
          //判断买、卖双方的数据是否和转换前一致
          assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
    
        }
    
        /**
         * 从主帐户合约调用者发送给别人代币
         * @param  _to address 接受代币的地址
         * @param  _value uint256 接受代币的数量
         */
        function transfer(address _to, uint256 _value) public {
            _transfer(msg.sender, _to, _value);
        }
    
        /**
         * 从某个指定的帐户中,向另一个帐户发送代币
         *
         * 调用过程,会检查设置的允许最大交易额
         *
         * @param  _from address 发送者地址
         * @param  _to address 接受者地址
         * @param  _value uint256 要转移的代币数量
         * @return success        是否交易成功
         */
        function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
            //检查发送者是否拥有足够余额
            require(_value <= allowance[_from][msg.sender]);   // Check allowance
    
            allowance[_from][msg.sender] -= _value;
    
            _transfer(_from, _to, _value);
    
            return true;
        }
    
        /**
         * 设置帐户允许支付的最大金额
         *
         * 一般在智能合约的时候,避免支付过多,造成风险
         *
         * @param _spender 帐户地址
         * @param _value 金额
         */
        function approve(address _spender, uint256 _value) public returns (bool success) {
            allowance[msg.sender][_spender] = _value;
            return true;
        }
    
        /**
         * 设置帐户允许支付的最大金额
         *
         * 一般在智能合约的时候,避免支付过多,造成风险,加入时间参数,可以在 tokenRecipient 中做其他操作
         *
         * @param _spender 帐户地址
         * @param _value 金额
         * @param _extraData 操作的时间
         */
        function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
            tokenRecipient spender = tokenRecipient(_spender);
            if (approve(_spender, _value)) {
                spender.receiveApproval(msg.sender, _value, this, _extraData);
                return true;
            }
        }
    
        /**
         * 减少代币调用者的余额
         *
         * 操作以后是不可逆的
         *
         * @param _value 要删除的数量
         */
        function burn(uint256 _value) public returns (bool success) {
            //检查帐户余额是否大于要减去的值
            require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
    
            //给指定帐户减去余额
            balanceOf[msg.sender] -= _value;
    
            //代币问题做相应扣除
            totalSupply -= _value;
    
            Burn(msg.sender, _value);
            return true;
        }
    
        /**
         * 删除帐户的余额(含其他帐户)
         *
         * 删除以后是不可逆的
         *
         * @param _from 要操作的帐户地址
         * @param _value 要减去的数量
         */
        function burnFrom(address _from, uint256 _value) public returns (bool success) {
    
            //检查帐户余额是否大于要减去的值
            require(balanceOf[_from] >= _value);
    
            //检查 其他帐户 的余额是否够使用
            require(_value <= allowance[_from][msg.sender]);
    
            //减掉代币
            balanceOf[_from] -= _value;
            allowance[_from][msg.sender] -= _value;
    
            //更新总量
            totalSupply -= _value;
            Burn(_from, _value);
            return true;
        }
    
    
    
        /**
         * 匿名方法,预防有人向这合约发送以太币
         */
        /*function() {
            //return;     // Prevents accidental sending of ether
        }*/
    }
    
    /**
     * @title 高级版代币
     * 增加冻结用户、挖矿、根据指定汇率购买(售出)代币价格的功能
     */
    contract MyAdvancedToken is owned, token {
    
        //卖出的汇率,一个代币,可以卖出多少个以太币,单位是wei
        uint256 public sellPrice;
    
        //买入的汇率,1个以太币,可以买几个代币
        uint256 public buyPrice;
    
        //是否冻结帐户的列表
        mapping (address => bool) public frozenAccount;
    
        //定义一个事件,当有资产被冻结的时候,通知正在监听事件的客户端
        event FrozenFunds(address target, bool frozen);
    
    
        /*初始化合约,并且把初始的所有的令牌都给这合约的创建者
         * @param initialSupply 所有币的总数
         * @param tokenName 代币名称
         * @param tokenSymbol 代币符号
         * @param centralMinter 是否指定其他帐户为合约所有者,为0是去中心化
         */
        function MyAdvancedToken(
          uint256 initialSupply,
          string tokenName,
          string tokenSymbol,
          address centralMinter
        ) token (initialSupply, tokenName, tokenSymbol) {
    
            //设置合约的管理者
            if(centralMinter != 0 ) owner = centralMinter;
    
            sellPrice = 2;     //设置1个单位的代币(单位是wei),能够卖出2个以太币
            buyPrice = 4;      //设置1个以太币,可以买0.25个代币
        }
    
    
        /**
         * 私有方法,从指定帐户转出余额
         * @param  _from address 发送代币的地址
         * @param  _to address 接受代币的地址
         * @param  _value uint256 接受代币的数量
         */
        function _transfer(address _from, address _to, uint _value) internal {
    
            //避免转帐的地址是0x0
            require (_to != 0x0);
    
            //检查发送者是否拥有足够余额
            require (balanceOf[_from] > _value);
    
            //检查是否溢出
            require (balanceOf[_to] + _value > balanceOf[_to]);
    
            //检查 冻结帐户
            require(!frozenAccount[_from]);
            require(!frozenAccount[_to]);
    
    
    
            //从发送者减掉发送额
            balanceOf[_from] -= _value;
    
            //给接收者加上相同的量
            balanceOf[_to] += _value;
    
            //通知任何监听该交易的客户端
            Transfer(_from, _to, _value);
    
        }
    
        /**
         * 合约拥有者,可以为指定帐户创造一些代币
         * @param  target address 帐户地址
         * @param  mintedAmount uint256 增加的金额(单位是wei)
         */
        function mintToken(address target, uint256 mintedAmount) onlyOwner {
    
            //给指定地址增加代币,同时总量也相加
            balanceOf[target] += mintedAmount;
            totalSupply += mintedAmount;
    
    
            Transfer(0, this, mintedAmount);
            Transfer(this, target, mintedAmount);
        }
    
        /**
         * 增加冻结帐户名称
         *
         * 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
         *
         * @param  target address 帐户地址
         * @param  freeze bool    是否冻结
         */
        function freezeAccount(address target, bool freeze) onlyOwner {
            frozenAccount[target] = freeze;
            FrozenFunds(target, freeze);
        }
    
        /**
         * 设置买卖价格
         *
         * 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格,也可以在这里设置
         *
         * @param newSellPrice 新的卖出价格
         * @param newBuyPrice 新的买入价格
         */
        function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
            sellPrice = newSellPrice;
            buyPrice = newBuyPrice;
        }
    
        /**
         * 使用以太币购买代币
         */
        function buy() payable public {
          uint amount = msg.value / buyPrice;
    
          _transfer(this, msg.sender, amount);
        }
    
        /**
         * @dev 卖出代币
         * @return 要卖出的数量(单位是wei)
         */
        function sell(uint256 amount) public {
    
            //检查合约的余额是否充足
            require(this.balance >= amount * sellPrice);
    
            _transfer(msg.sender, this, amount);
    
            msg.sender.transfer(amount * sellPrice);
        }
    }

      
      参考之前的方法,在 Mist 中重新部署合约,贴完代码后,在右侧选择 My Advanced TokenInitial Supply 输入初始金额5000,Token name 输入我们的代币名称 陌上花开AToken symbol 代币符号我们输入 #,然后点击部署,输入部署帐户的密码。

    mshk.top

      
      创建成功以后,我们在合约列表页,可以看到刚才创建的新合约陌上花开A

    mshk.top

      
      点击 Mist 上面的发送,我们先给帐户0xd29adaadf3a40fd0b68c83c222c10d3ea637dce0转入100个以太币。

    mshk.top

      
      操作成功以后,我们能够在钱包页面看到Account 4已经有了100以太币。

    mshk.top

    7.6、使用以太币购买代币

      接下来,我们进入合约页面,使用以太币购买 陌上花开A 代币,进入合约界面后,我们能够看到代币上的以太币是 0 ether,在右侧选择 Buy 方法,Execut from 选择 Account 4,在 Send ether 输入 10 个以太币,点击 执行

    mshk.top

      
      执行成功以后,能够看到当前页面自动刷新,合约中已经有了10 ether,代币的总量不变

    mshk.top

      
      再次回到 钱包 页面,可以看到 Account 4 已经从 100 ether 变成了 90 ether,并且多了一个代币图标。

    mshk.top

      
      点击 Account 4 帐号进去,可以看到一些详细信息,ether的总量是 89,999081514 而不是 90,是因为执行合约的时候,我们会消费一定的 gas。我们设置的费率是1:4,所以 10 ether,只可以购买 2.5陌上花开A 代币,最小单位也是wei,所以是 2,500000000000000000

    mshk.top

    7.7、卖出代币

      进入合约界面后,我们能够看到代币上的以太币是 10 ether,在右侧选择 Sell 方法,在 Amount 处输入 2000000000000000000(因为我们刚才购买了2.5个代币,现在卖出2个,卖出的最小单位是wei),Execut from 选择 Account 4,点击 执行

    mshk.top

      
      执行以后,在代币的详情页面,能够看到从 10 ether变成了 6 ether,因为刚才 Account 4 卖出了 2陌上花开A 代币,而我们设置的卖价是 1个代币 能卖出 2个以太币

    mshk.top

      
      再次回到 Account 4 的详情页面,能够看到以太币变成了 93,998273026,而 陌上花开A 代币的数量,变成了 0,500000000000000000

    mshk.top

    8、常见问题

    8.1、在调试Mist的过程中,创建了很多个合约,如何删除?

      In the Ethereum Wallet (Mist) menu, click on Develop -> Toggle Developer Tools -> Wallet UI. Click on the Console tab

    CustomContracts.find().fetch().map(
       function(m) { CustomContracts.remove(m._id);}
    )

    博文作者:迦壹
    博客地址:Go-Ethereum 1.7.2 结合 Mist 0.9.2 实现代币智能合约的实例
    转载声明:可以转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明,谢谢合作!


    展开全文
  • 区块链概念股有哪些

    2018-09-09 12:54:28
    进入区块链平台试图通过区块链分布式账本和自己的代币使得酒店的预定流程分散。目标是在旅行者和酒店之间建立一个更直接的联系,允许P2P交互,免除与中介和OTA相关的佣金和其他费用。 通过启用直接访问功能,用户还...
  • 在本文中,我们将说明在Waves生态系统中使用AMM服务Swop.fi时应准备应对哪些风险。 首先,如果您打算仅将Swop.fi用于令牌交换,则几乎不存在风险。的确,如果其他用户在您之前进行掉期交易,则价格可能会突然改变。...
  • 3、Mist 有哪些依赖?4、如何安装 Mist?4.1、安装 Mist 依赖工具包4.2、安装 Mist4.3、启动 Mist,连接到 Geth5、使用 Mist 部署一个简单的智能合约6、改善代币6.1、如何部署7、高级版的代币功能7.1、去中心化的...
  • NFT 项目都有哪些?三、Near下获取NFT实践1. 关于MintbaseMintbase 为什么选择nearMintbase 工作原理2. 在 Mintbase 上购买NFT 实践四、参考 一、什么是NFT 1. NFT概念 一般说来,加密数字货币可分为两类:同质化...
  • 人说就在最近这两三年,还人甚至说就在今年,2018年区块链将会出现井喷。现在2018年已经即将结束,我们也是见证了这个预言的准确性。2018年的区块链从技术到媒体到开发和代币,都呈现出了井喷式的爆发。  那么...
  • 以太坊:什么是ERC20标准? 不以规矩,不能成方圆 许多人应该都听过 代码即法律(Code Is Law),因为...接触过数字货币的人都应该知道,以太坊是一个分布式的智能合约平台,可以分发代币(Token)。目前以太坊上24351...
  • ◆区块链的共识机制▪在...权益证明机制Pos▪Pow通过评估你的工作量来决定你获得记账权的机率(工作量越大就可能获得此次记账机会)▪Pos通过评估你持有代币的数量和时长来决定你获得记账权的机率(类似于股票的分...
  • 熊市已经过了很长一段时间了,如此长的寒冬,让很多人都少了投资的欲望,大家都收紧预算,拿着现金,以图后机。...现存的代币有上千种,币圈又比较混乱,到底该投什么好呢? 根据笔者的思考,未来会在牛市中爆...
  • 用户最愿意为哪些协议付费? Maker的大部分收入来自哪里? 相对于其他市场,Aave的表现如何? 就创收而言,哪种协议最便宜? 现在已经这些问题的答案了。所以当主流金融机构在加密牛市周期中注意到了这一点的话..
  • 基于托管的质押池:在充分管理的计划的基础上,提供权益池代币以解决ETH的长期流动性问题; 非托管云服务:用户保留对ETH资产的控制权和质押收益,并使用两个密钥与服务提供商共同管理验证节点。 、 自建节点解决...
  • 区块链是分布式数据存储、点对点传输、共识机制、加密算法等计算机技术的新型应用模式,本质上是一个去中心化的数据库,同时作为比特币的底层技术。...目前95%以上的项目所发行的代币均为采用以太坊ERC20标准发.
  • ALOKEX 交易所具有行业内最为...ALOKEX交易所不仅可以为项目方和投资者提供代币发行、交易、定存等传统服务,还囊括资讯流通、社交自主,专业一对一跟单等多元化服务,可满足用户多样化需求,快速提高平台效率,帮助
  • Nebulas代币简称:NAS主网上线时间:2018.3.30ICO价格:$1.91最新排名:65简介:区块链的搜索引擎AION代币简称:AION主网上线时间:2018.04.25ICO价格:$0.875最新排名:56简介:连接其它区块链Waykichain代币简...
  • 据Cointelegraph消息,白俄罗斯政府已提议将高科技园区管理局(Hi-Tech Park Administration,HTP)作为当地加密货币交易所和数字代币的监管机构。 第一副总理Nikolai Snopkov表示,政府目前正在尝试选择合适的机构...
  • 自2014年由Protocol Labs打造的IPFS协议发展...Filecoin是IPFS的激励层代币,从2020年10月15日上线至今仅仅5个月,不仅Fil币市值上涨54%,基于IPFS高效率、高安全的特性,全世界范围内已经开发出分布式网络中更易于互
  • 什么区别?两种钱包存储的币种是不同的。imToken钱包只能存储以太系ERC20标准的代币,而非ERC20标准的代币就不能存放,比如比特币就是无法存放的;比特派钱包仅能放几个主流的ERC20标准的代币,同时也能存比特币、...
  • 今日21.00时(GMT+8)起,Atlas主网HYN及节点映射将正式开启!...主网代币有哪些优势 映射完可立即抵押创建或参与主网节点,成功启动的Map3节点可复抵押获取出块奖励 主网节点扩容后,最小抵押量门槛降低至55w个H..
  • 那么问题就是到底哪几种代币?怎么在一个程序中可以添加多种代币?(我了解到BTC和以太坊的都是不同的开发API,基于以太坊的代币可以通过合约的方式来操作?) - 通过助记词生成的base seed这种怎么在它下面新增...
  • 备受关注的加密项目Filecoin终于主网上线,各大交易所纷纷上线Filecoin代币FIL,这也推动了其价格的上涨。北京时间周四晚间,Filecoin区块高度达到主网上线高度。随后Filecoin官方发文称,Filecoin主网已正式上线,...
  • 即使在这个不确定的时代,加密市场也一直在稳步增长,给投资者带来了新的机会,而且代币销售的市场热度在2020年也回归的迹象。 然而,在当今的加密市场,代币销售并不是赚钱的唯一途径。 随着DeFi市场的蓬勃发展,...
  • 即使在这个不确定的时代,加密市场也一直在稳步增长,给投资者带来了新的机会,而且代币销售的市场热度在2020年也回归的迹象。 然而,在当今的加密市场,代币销售并不是赚钱的唯一途径。 随着DeFi市场的蓬勃发展...
  • NFT又有哪些特性值得看重呢, NFT的独有性 NFT是不可互换的资产,它具有独一无二的属性。这意味着,如果NFT资产本身是稀缺的,它也会承载其价值,不可被篡改或复制,或替换。 NFT的恒久性 NFT一般基于公链发行,例如...
  • 虽然不是所有区块链项目都必须通证,但没有通证经济作为基础的项目,本质上和中心化项目没什么区别。于是如果你仔细研究各大区块链游戏中的白皮书,它们不约而同一定都会一定篇幅详细描绘游戏中的通证经济设计。...
  • ​2020年最后1周,币圈最大的雷就是XRP代币背后的公司Ripple被美国证监会SEC调查,美国最大虚拟货币交易所Coinbase下架XRP代币。而在2020年最后2天,率先剧透Coinbase将下架XRP的爆料人AdamCochran又在推特上写了一...
  • 据DeFiMarketCap数据显示,7月5日,DeFi(去中心化金融)代币的总市值已突破70亿美元。 6月初,DeFi的总市值不过20亿美金上下,7月初,就飙涨到了70亿美金。仅仅一个月时间,涨幅达250%,DeFi热潮可见一斑。 强大刚...

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

代币有哪些