怎么在区块链上开发可更新的智能合约

这篇文章主要介绍“怎么在区块链上开发可更新的智能合约”，在日常操作中，相信很多人在怎么在区块链上开发可更新的智能合约问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”怎么在区块链上开发可更新的智能合约”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

由于区块链不可篡改的特性，智能合约一旦部署在区块链上，其执行的逻辑就无法再更改。长期来看，这个重要的特性反而限制了智能合约的弹性和发展。

接下来要介绍如何设计及部署合约才能让合约在需要时可以更新。但这里的更新意思不是修改已经部署的合约，而是部署新的合约、新的执行逻辑但同时能继续利用已经存在的资料。

首先要知道的是Ethereum Virtual Machine(EVM)要知道如何执行合约的那个函数。合约最后都会被编译成字节码，而你发起一个transaction要执行合约里的某个函数时，交易里的数据同样也是字节码，而不是人看得懂的函数名称。 以一个简单的合约为例：

contract Multiply {
    function multiply(int x, int y) constant returns(int) {
        return x*y; 
    }
}

编译完的二进制码：

6060604052341561000c57fe5b5b60ae8061001b6000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680633c4308a814603a575bfe5b3415604157fe5b605e60048080359060200190919080359060200190919050506074565b6040518082815260200191505060405180910390f35b600081830290505b929150505600a165627a7a72305820c40f61d36a3a1b7064b58c57c89d5c3d7c73b9116230f9948806b11836d2960c0029

如果你要执行multiply函数，算出8*7等于多少，你的transaction里的数据是 0x3c4308a800000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000007 
分成三部分： 第一个是四个字节的3c4308a8，第二和第三个分別是32个字节长的参数，8和7。

3c4308a8是multiply函数的signature（签名），是取函数名称和参数类型使用sha3取前四个byte而得到（不包含0x）：

sha3("multiply(int256,int256)"));
//0x3c4308a8851ef99b4bfa5ffd64b68e5f2b4307725b25ad0d14040bdb81e3bafc sha3("multiply(int256,int256)")).substr(2,8);
//3c4308a8

EVM就是靠函数的signature来知道该执行那个函数的。在合约编译完的字节码里查询也能找到这个signature。

接下来要介紹Solidity里的三种调用方式：call、callcode和delegatecall。

• call：一般的调用都是这种方式，执行背景跳到下一个函数的环境（这里的环境是指msg的值和合约的Storage）。如果被调用的是不同合约的函数那么变换成被调用的合约的环境，且msg.sender编程调用者。

• callcode：和call相同，只是将被调用函数搬到调用者的环境里执行。
  假设A合约的x函数用callcode方式调用B合约的y函数，就会在A合约里执行y函数，使用A的参数，所以如果y函数里修改某个参数的值且这个参数的名称刚好和A的某个参数名称一致，则A的该参数就会被修改。就把它想像成A多了一个y函数并执行。

• delegatecall：和callcode相同，都是把被调用的函数搬到调用者的环境里执行，只是在msg.sender的值上有区别。
  来看一个例子：加入A合约用delegatecall的方式调用B合约的函数，B合约的函数接下用callcode或call的方式调用C合约的函数，那么函数里看到的msg.sender会是B；但如果B改用delegatecall的方式调用C合约的函数的话，那么函数里看到的msg.sender会是A。就把它想像成把msg相关的值保持不变传递下去就ok了。

接下来实际来看一下delegatecall的效果：

contract Plus {
    int z;
    function plus(int x, int y) {
        z = x+y;
    }
}
contract Multiply {
    int public z;
    function multiply(int x, int y) {
        z = x*y;
    }
    function delegateToPlus(address _plus, int x, int y) {
        _plus.delegatecall( bytes4(sha3("plus(int256,int256)")) ,x ,
        y);
    }
}

部署并按顺序执行Multiply的multiply和delegateToPlus并观察z值的变化：

可以看到执行delegatecall之后z的值变成是8+7。 所以如果要让我们未来可以改变执行逻辑的话怎么写代码呢？

contract Plus {
    int z;
    function plus(int x, int y) { //sig:"0xccf65503"
        z = x+y;
    }
}
contract Multiply {
    int z;
    function multiply(int x, int y) { //sig:"0x3c4308a8"
        z = x*y;
    }
}
contract Main {
    int public z;
    function delegateCall(address _dest, bytes4 sig, int x, int y) {
        _dest.delegatecall(sig, x , y);
    }
}

我们将合约的地址和函数的signature当做参数传递给delegateCall去执行，假设原本是用Plus合约的执行路基，现在我们更新成Multiply合约：

0x4429 是Plus合约的地址， 0xe905 是Multiply合约的地址。
我们以后只要给它改变后的函数signature和合约地址就可以使用新的执行逻辑了！

但如果合约不是只给一个人使用的话，应当在更新合约的時候所有参与的人都必须要更新新合约的位置。这时候可以用一个合约来帮助我们导到新的合约位置，就像路由器似的，我们统一发送(还是以delegatecall的形式)到路由合约，再由路由合约帮我们导到正确的位置，未来更新合约就只需要更新路由合约的资料即可。

contract Upgrade {
    mapping(bytes4=>uint32) returnSizes;
    int z;
    
    function initialize() {
        returnSizes[bytes4(sha3("get()"))] = 32;
    }
    
    function plus(int _x, int _y) {
        z = _x + _y;
    }
    function get() returns(int) {
        return z;
    }
}
contract Dispatcher {
    mapping(bytes4=>uint32) returnSizes;
    int z;
    address upgradeContract;
    address public dispatcherContract;
    function replace(address newUpgradeContract) {
        upgradeContract = newUpgradeContract;
        upgradeContract.delegatecall(bytes4(sha3("initialize()")));
    }
    function() {
        bytes4 sig;
        assembly { sig := calldataload(0) }
        var len = returnSizes[sig];
        var target = upgradeContract;
        
        assembly {
            calldatacopy(mload(0x40), 0x0, calldatasize)
            delegatecall(sub(gas, 10000), target, mload(0x40),
                         calldatasize, mload(0x40), len)
            return(mload(0x40), len)
        }
    }
}
contract Main {
    mapping(bytes4=>uint32) public returnSizes;
    int public z;
    address public upgradeContract;
    address public dispatcherContract;
    
    function deployDispatcher() {
        dispatcherContract = new Dispatcher();
    }
    
    function updateUpgrade(address newUpgradeContract) {
        dispatcherContract.delegatecall(
            bytes4( sha3("replace(address)")), newUpgradeContract
        );
    }
    
    function delegateCall(bytes4 _sig, int _x, int _y) {
        dispatcherContract.delegatecall(_sig, _x, _y);
    }
    
    function get() constant returns(int output){
        dispatcherContract.delegatecall(bytes4( sha3("get()")));
        assembly {
            output := mload(0x60)
        }
    }
}

执行顺序：
1. 执行Main.deployDispatcher() 部署路由合约
2. 部署upgrade合约并将其address当做Main.updateUpgrade()的参数传入用来更新upgrade合约的地址资料。
3. 执行Main.delegateCall()，参数是plus(int256,int256)的signature和任意两个值。
4. 执行Main.get()，由delegatecall去调用upgrade合约的get函数，回传相加完的z值。因为是delegatecall，所以这个z值其实是Main合约自己的，upgrade合约的z值是零。

如果delegatecall调用的函数有返回值的话，必须要用assembly来手动获得返回值，因为delegatecall和call一样，只会回传true of false来代表执行是否成功。Dispatcher在调用是同样也是用assembly code。
但因为是用assembly手动获得返回值，因此前提是返回值的长度必须是固定且已知的，所以当我们在步骤2更新upgrade合约时，Dispatcher合约同时去调用upgrade合约的initialize()函数，upgrade合约在initialize函数里将它所有会有返回值的函数的返回值大小写入returnSizes中，之后如果调用具有返回值的函数时，Dispatcher就知道返回值的大小了。

這个还有一个重点是参数定义的顺序
因为合约执行要用参数值的时候，它会到对应的Storage位置去找。所以如果你的合约参数定义像這樣子
upgrade:
int x
int y
 — — — — 
Dispathcer:
int x
int y
 — — — — 
Main:
int x
int abc
int y
当upgrade合约的函数需要用到x和y的值的时候，它会找不到y，因为Storage是Main的。

到此，关于“怎么在区块链上开发可更新的智能合约”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注亿速云网站，小编会继续努力为大家带来更多实用的文章！