涉及到动态数组时Solidity与Vyper智能合约相互调用方法

2024-03-02 22:59:52

涉及到动态数组时Solidity与Vyper智能合约相互调用

前言

我们知道，当前以太坊的智能合约编程语言主要有两种，一种叫Solidity，大家很熟悉了；一种叫Vyper，虽然是后起之秀，但比较小众，用到的项目很少。Vyper的安全性其实是高于Solidity的，但为什么这么小众呢？个人觉得最主要的原因是不支持动态数组，这样使用它来编写复杂的应用就太麻烦了。

那么问题来了，如果一个智能合约是Solidity编写的而另一个智能合约是Vyper编写的。它们之间要相互调用，但是涉及的接口在Solidity中使用了动态数组作为输入输出参数，在Vyper中使用了固定大小的数组作为输入输出参数。那么他们之间怎么调用呢？

直接调用？会由于参数不匹配而调用失败。那能不能相互调用，怎么调用呢？凡事要打破沙锅问到底，要弄明白。因为不管什么语言写的智能合约，运行的都是字节码，底层调用时都是操作码，因此个人觉得相互之间是可以调用的。但觉得没有用，得亲自实践，必须得研究尝试。经过反复测试，发现它们之间是可以相互调用的，虽然有些限制。

合约编写

为了进行测试，我们准备了三个合约。合约A,使用Solidity编写，提供一个输入输出参数都是动态数组的接口。合约B，使用VYPER编写，提供一个输入输出参数都是固定大小数组的接口。合约C，使用Solidity编写，分别调用A和B的接口进行测试。

使用Solidity编写的合约A和C的源代码如下：

pragma solidity ^0.6.0;

//Vyper 合约B，使用fixed list。
interface IB {
    function callTwice(uint[] calldata source) external pure returns(uint[] memory target);
}

//合约A 使用Solidity 动态数组
contract A {
    function callTwice(uint[] calldata source) external pure returns(uint[] memory target) {
        uint len = source.length;
        target = new uint[](len);
        for(uint i=0;i<len;i++){
            target[i] = 2 * source[i];
        }
    }
}

//测试合约C，用来分别调用A和B的callTwice
contract C {
    address public a;
    address public b;
    constructor(address _a,address _b) public {
        a = _a;
        b = _b;
    }

    //直接调用Solidity合约的callTwice(uint256[])
    function callTwiceA(uint[] calldata source) external view returns(uint[] memory) {
        return A(a).callTwice(source);
    }

    //直接调用Vyper合约的callTwice(uint256[3])
    function callTwiceB(uint[] calldata source) external view returns(uint[] memory) {
        return IB(b).callTwice(source);
    }

    //原生方法调用Vyper合约的callTwice(uint256[3])
    function callTwiceBRaw(uint[] calldata source) external view returns(uint[] memory result ) {
        source;
        bytes memory bts2 = hex"b638652e";   //bytes4(keccak256(bytes("callTwice(uint256[3])")))
        bytes memory b3 = concat(bts2,bytes(msg.data[68:])); // 4 + offset + length of array
        (bool success, bytes memory returnData) = b.staticcall(b3);
        require(success, "staticcall failed");
        uint[3] memory datas = abi.decode(returnData, (uint[3]));
        result =  new uint[](3);
        for(uint i=0;i<3;i++){
            result[i] = datas[i];
        }
    }

    function concat(bytes memory one, bytes memory two)
            internal pure returns (bytes memory) {
        return abi.encodePacked(one, two);
    }
    
}

Vyper编写的合约B源码如下：

# @version 0.1.0b16

# Solidity 合约A ，用来调用其callTwice方法
contract IA:
    def callTwice(source:uint256[3]) -> uint256[3]: constant


a:public(address)


@public
def __init__(_a:address):
    self.a = _a


# 自己的callTwice方法，提供给Solidity合约调用
@public
@constant
def callTwice(source:uint256[3]) -> uint256[3]:
    result: uint256[3] =  [0,0,0]
    for i in range(3):
        result[i] = source[i] * 2
    return result


# 直接调用A的callTwice方法，由于参数不符，调用会失败
@public
@constant
def callTwiceA(source:uint256[3]) -> uint256[3]:
    return  IA(self.a).callTwice(source)


#解析返回的结果
@private
def uintArrayResponse(unitBytes: bytes[160]) -> uint256[3]:
    result: uint256[3] = [0,0,0]
    for i in range(3):
        start: int128 = 32*(2+i)
        extracted: bytes32 = extract32(unitBytes, start, type=bytes32)
        result[i] = convert(extracted, uint256)
    return result


# 通过原生方式调用合约A的callTwice方法，注意此方法无法标记为@constant，但是不影响外部获取结果。
@public
def callARaw(source:uint256[3]) -> uint256[3]:
    funcSig: bytes[4] = method_id("callTwice(uint256[])", bytes[4])
    #offset + lengthOfInputArray + inputArray
    uintBytes: bytes[160] = concat(
                                convert(32, bytes32),
                                convert(3, bytes32),
                                convert(source[0], bytes32),
                                convert(source[1], bytes32),
                                convert(source[2], bytes32)
                            )
    full_data: bytes[164] = concat(funcSig, uintBytes)
     # returns byteArray of offset (32 bytes) + length (32 bytes) + uintArray (32 * 3)
    response: bytes[160] = raw_call(
                                self.a,           # Compound Comptroller address
                                full_data,          # funcSig + offset + lengthOfInputArray + inputArray
                                outsize=160,         # outsize = offset (32 bytes) + length (32 bytes) + addressArray (32 * 1)
                                gas=msg.gas,        # Pass msg.gas for call
                                value=0,            # Make sure to not send ETH
                                delegate_call=False # Not delegate_call
                                # static_call=True
                              )
    return self.uintArrayResponse(response)

合约代码都不是很难，也加上了注释，这里就不再讲解了。

编译部署

我们可以使用truffle + ganache来在本地编译部署智能合约并进行测试。truffle 和 ganache的基本使用相信大家都会了，这里简单介绍一下truffle编译vyper智能合约的方法：

安装python 3.6以上
使用pip安装指定版本的vyper编译器，例如 `pip install vyper==0.1.0b16
truffle compile

这里具体编译和部署的过程就跳过去了，比较简单的。

测试脚本

既然涉及到Vyper,而Vyper又使用了Python语法，我们就使用python来测试好了。

前提： 安装web3.py

测试脚本如下：

from contract import A,B,C
from web3.auto import w3

source = [1,2,3]


#计算函数选择器,参数示例：func = 'callTwice(uint235[3])'
def calSelectorByPython(_func):
    result = w3.keccak(text=_func)
    selector = (w3.toHex(result))[:10]
    return selector


def testNormal():
    r1 = A.functions.callTwice(source).call() #solidity
    r2 = B.functions.callTwice(source).call() #vyper
    print(r1) # 输出[2,4,6]
    print(r2) # 输出[2,4,6]


def testC():
    r1 = C.functions.callTwiceA(source).call() #Solidity => Solidity
    print(r1) # 输出[2,4,6]
    r2 = C.functions.callTwiceB(source).call() #Solidity => vyper
    print(r2)  #会失败
   
def testCRaw():
    r = C.functions.callTwiceBRaw(source).call() #Solidity => vyper(raw)
    print(r)  # 输出[2,4,6]

def testBToA():
    r = B.functions.callTwiceA(source).call() # vyper => solidity
    print(r) #会失败


def testBToARaw():
    r = B.functions.callARaw(source).call() # vyper => solidity (raw)
    print(r) # 输出[2,4,6]

这里A,B,C是三个合约的实例，具体怎么生成的我这里不再列出了，有兴趣的读者可以看一下web3.py相关内容。
这里只是简单讲一下它的测试接口：

calSelectorByPython 计算函数选择器，合约调用时是根据函数选择器来匹配对应的函数的。
testNormal 分别使用外部账号正常调用合约A和C的接口，输出正确结果
testC分为两个操作，操作1在C中直接调用A合约的接口，注释中提到了是Solidity之间相互调用，输出正确结果。操作2在C中直接调用合约B的接口，注释中提到了是Solidity调用Vyper，由于动态数组的问题，这里的参数不会匹配，调用失败。
testCRaw 在C中使用原生（底层）方法来调用合约B的接口，这里绕过了一些检查，因此调用成功，输出正确。
testBToA 同testC第二步相反，我们在B中直接调用合约A的相关接口，这里同样由于动态数组的问题，参数不匹配，调用失败。
testBToARaw 我们在B中通过底层方法调用合约A的相关接口，这里绕过了一些检查，因此调用成功，输出正确。

从上面五个测试中，我们可以得出：涉及到动态数组时，Vyper与Solidity智能合约之间相互直接调用会失败，必须通过底层调用才能成功。

但是底层调用一是复杂费力，二是每个函数都要写单独的匹配方法，无法复用。

结论：当涉及到动态数组时，请使用Solidity，请使用Solidity，请使用Solidity，重要的事情说三遍！

由于这个原因，Vyper仅适合小众的项目，或者不需要动态数组的项目。

码农公寓