以太坊合约地址计算-Toy模板网

这篇具有很好参考价值的文章主要介绍了以太坊合约地址计算。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1. 引言

前序博客有：

以太坊proxy合约

以太坊合约实现中，为实现可升级性、地址一致性、state和data 与合约逻辑分离，proxy承担了重要的角色。在proxy合约中，合约部署主要采用过CREATE(0xf0) 和CREATE2(0xf5) opcode。

以太坊创建合约的方式有2种：

1）由EOA账号直接创建合约

2）由其它智能合约创建智能合约

2.1）通过CREATE(0xf0) opcode：合约地址由keccak256(sender, nonce)确定。
CREATE方式简单，但存在不同网络重放问题，详细见Wintermute hack on Optimism攻击。
2.2）通过CREATE2(0xf5) opcode：合约地址由keccak256(0xff, sender, salt, keccak256(bytecode))确定。引入0xff是为了避免CREATE2创建的合约地址与CREATE的发生碰撞。因为0xff byte，作为RLP编码的starting byte时，对应的数据结构长度将为PB（petabytes）级，这在以太坊合约及数据结构中是不可能达到的。
借助CREATE2，可能可通过Metamorphosis Smart Contract Pattern，将不同的bytecode部署到同一地址。详细参看Metamorphosis Smart Contracts using CREATE2。
为避免不同链之间的重放，推荐使用基于old salt和unique data（如inputs或unique data hash）来派生new salt：bytes20 newSalt = bytes20(keccak256(abi.encodePacked(_initializerData, _salt)));。

// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;

contract OpCreates {
    function opCreate(bytes memory bytecode, uint length) public returns(address) {
        address addr;
        assembly {
            addr := create(0, 0xa0, length)
            sstore(0x0, addr)
        }
        return addr;
    }

    function opCreate2(bytes memory bytecode, uint length) public returns(address) {
        address addr;
        assembly {
            addr := create2(0, 0xa0, length, 0x2)
            sstore(0x0, addr)
        }
        return addr;
    }

    function sendValue() public payable {
        uint bal;
        assembly{
            bal := add(bal,callvalue())
            sstore(0x1, bal)
        }
    }

    function opCreateValue(bytes memory bytecode, uint length) public payable returns(address) {
        address addr;
        assembly {
            addr := create(500, 0xa0, length)
            sstore(0x0, addr)
        }
        return addr;
    }

    function opCreate2Value(bytes memory bytecode, uint length) public payable returns(address) {
        address addr;
        assembly {
            addr := create2(300, 0xa0, length, 0x55555)
            sstore(0x0, addr)
        }
        return addr;
    }
}

2. 由EOA账号直接创建的合约——合约地址计算

由EOA账号直接创建的合约——合约地址计算规则，根据pyethereum有：

try:
    from Crypto.Hash import keccak
    sha3_256 = lambda x: keccak.new(digest_bits=256, data=x).digest()
except:
    import sha3 as _sha3
    sha3_256 = lambda x: _sha3.sha3_256(x).digest()

def mk_contract_address(sender, nonce):
    return sha3(rlp.encode([normalize_address(sender), nonce]))[12:]

即采用sender-and-nonce-hash方式来计算合约地址。

以太坊合约的地址是根据creator地址（sender）和该creator已发送的交易数（nonce）经RLP编码再采用Keccak-256哈希运算 确定性计算而来的：【下述示例应进一步拓展为支持nonce最大值 $2^{64}$ 】

// Solidity 0.8及以上
function addressFrom(address _origin, uint _nonce) public pure returns (address) {
    bytes memory data;
    if (_nonce == 0x00)          data = abi.encodePacked(byte(0xd6), byte(0x94), _origin, byte(0x80));
    else if (_nonce <= 0x7f)     data = abi.encodePacked(byte(0xd6), byte(0x94), _origin, byte(_nonce));
    else if (_nonce <= 0xff)     data = abi.encodePacked(byte(0xd7), byte(0x94), _origin, byte(0x81), uint8(_nonce));
    else if (_nonce <= 0xffff)   data = abi.encodePacked(byte(0xd8), byte(0x94), _origin, byte(0x82), uint16(_nonce));
    else if (_nonce <= 0xffffff) data = abi.encodePacked(byte(0xd9), byte(0x94), _origin, byte(0x83), uint24(_nonce));
    else                         data = abi.encodePacked(byte(0xda), byte(0x94), _origin, byte(0x84), uint32(_nonce));
    return address(keccak256(data));
}
// Solidity 0.6
function addressFrom(address _origin, uint _nonce) public pure returns (address) {
    bytes memory data;
    if (_nonce == 0x00)          data = abi.encodePacked(byte(0xd6), byte(0x94), _origin, byte(0x80));
    else if (_nonce <= 0x7f)     data = abi.encodePacked(byte(0xd6), byte(0x94), _origin, uint8(_nonce));
    else if (_nonce <= 0xff)     data = abi.encodePacked(byte(0xd7), byte(0x94), _origin, byte(0x81), uint8(_nonce));
    else if (_nonce <= 0xffff)   data = abi.encodePacked(byte(0xd8), byte(0x94), _origin, byte(0x82), uint16(_nonce));
    else if (_nonce <= 0xffffff) data = abi.encodePacked(byte(0xd9), byte(0x94), _origin, byte(0x83), uint24(_nonce));
    else                         data = abi.encodePacked(byte(0xda), byte(0x94), _origin, byte(0x84), uint32(_nonce));
    return address(uint256(keccak256(data)));
}

可借助汇编代码进一步优化以节约gas费：

// Solidity 0.8及以上
function addressFrom(address _origin, uint _nonce) external pure returns (address _address) {
    bytes memory data;
    if(_nonce == 0x00)          data = abi.encodePacked(bytes1(0xd6), bytes1(0x94), _origin, bytes1(0x80));
    else if(_nonce <= 0x7f)     data = abi.encodePacked(bytes1(0xd6), bytes1(0x94), _origin, uint8(_nonce));
    else if(_nonce <= 0xff)     data = abi.encodePacked(bytes1(0xd7), bytes1(0x94), _origin, bytes1(0x81), uint8(_nonce));
    else if(_nonce <= 0xffff)   data = abi.encodePacked(bytes1(0xd8), bytes1(0x94), _origin, bytes1(0x82), uint16(_nonce));
    else if(_nonce <= 0xffffff) data = abi.encodePacked(bytes1(0xd9), bytes1(0x94), _origin, bytes1(0x83), uint24(_nonce));
    else                        data = abi.encodePacked(bytes1(0xda), bytes1(0x94), _origin, bytes1(0x84), uint32(_nonce));
    bytes32 hash = keccak256(data);
    assembly {
        mstore(0, hash)
        _address := mload(0)
    }
}
	// Solidity 0.6
    function addressFrom(address _origin, uint _nonce) public pure returns (address _address) {
        bytes memory data;
        if(_nonce == 0x00)          data = abi.encodePacked(byte(0xd6), byte(0x94), _origin, byte(0x80));
        else if(_nonce <= 0x7f)     data = abi.encodePacked(byte(0xd6), byte(0x94), _origin, uint8(_nonce));
        else if(_nonce <= 0xff)     data = abi.encodePacked(byte(0xd7), byte(0x94), _origin, byte(0x81), uint8(_nonce));
        else if(_nonce <= 0xffff)   data = abi.encodePacked(byte(0xd8), byte(0x94), _origin, byte(0x82), uint16(_nonce));
        else if(_nonce <= 0xffffff) data = abi.encodePacked(byte(0xd9), byte(0x94), _origin, byte(0x83), uint24(_nonce));
        else                        data = abi.encodePacked(byte(0xda), byte(0x94), _origin, byte(0x84), uint32(_nonce));
        bytes32 hash = keccak256(data);
        assembly {
            mstore(0, hash)
            _address := mload(0)
        }
    }

3. 由其它智能合约创建合约——合约地址计算

在EIP-1014：Skinny CREATE2中，额外引入了新的opcode CREATE2(0xf5)来创建智能合约。CREATE2(0xf5)与CREATE(0xf0)的工作模式相同，只是CREATE(0xf0)计算合约地址采用sender-and-nonce-hash方式，而CREATE2(0xf5)采用合约地址计算规则为：

keccak256( 0xff ++ senderAddress ++ salt ++ keccak256(init_code))[12:]

参考资料

[1] How to calculate an Ethereum Contract’s address during its creation using the Solidity language?
[2] How is the address of an Ethereum contract computed?
[3] 2023年4月博客 Deep Dive into Smart Contract Proxies: Variants, CREATE vs. CREATE2, and Security Considerations文章来源地址https://www.toymoban.com/news/detail-785944.html

到了这里，关于以太坊合约地址计算的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！