区块链系统合约升级机制

引言

在区块链系统中，系统合约的升级是一个关键但复杂的问题。本文将详细介绍BSC的系统合约升级机制，通过分叉配置实现平滑升级。

核心原理

系统合约升级通过分叉配置实现：

1. 在创世区块配置中定义分叉高度

2. 在代码中预定义新合约字节码

3. 当区块达到指定高度时，自动替换合约代码

4. 合约存储数据保持不变

架构设计

 

详细实现步骤

1. 合约字节码的存储结构

合约字节码存储在以下目录结构中：

 

 

2. 创建新的分叉目录和合约字节码

# 在 core/systemcontracts/ 下创建新的分叉目录

mkdir -p core/systemcontracts/myCustomUpgrade/chapel

mkdir -p core/systemcontracts/myCustomUpgrade/mainnet

 

# 将编译好的合约字节码放入对应目录

3. 创建 types.go 文件定义变量

// core/systemcontracts/myCustomUpgrade/types.go
package myCustomUpgrade

import _ "embed"

// contract codes for Chapel upgrade
var (
    //go:embed chapel/ValidatorContract
    ChapelValidatorContract string
    //go:embed chapel/SlashContract
    ChapelSlashContract string
    // ... 其他合约
)

// contract codes for Mainnet upgrade
var (
    //go:embed mainnet/ValidatorContract
    MainnetValidatorContract string
    // ... 其他合约
)

4. 在 upgrade.go 中添加升级配置

// core/systemcontracts/upgrade.go

// 添加新的升级变量
var myCustomUpgrade = make(map[string]*Upgrade)

func init() {
    // ... 现有代码 ...
    
    // 添加您的自定义升级配置
    myCustomUpgrade[chapelNet] = &Upgrade{
        UpgradeName: "myCustomUpgrade",
        Configs: []*UpgradeConfig{
            {
                ContractAddr: common.HexToAddress(ValidatorContract),
                CommitUrl:    "https://github.com/your-repo/commit/xxx",
                Code:         myCustomUpgrade.ChapelValidatorContract,
            },
            {
                ContractAddr: common.HexToAddress(SlashContract),
                CommitUrl:    "https://github.com/your-repo/commit/xxx",
                Code:         myCustomUpgrade.ChapelSlashContract,
            },
            // ... 其他合约
        },
    }
}

func upgradeBuildInSystemContract(config *params.ChainConfig, blockNumber *big.Int, lastBlockTime uint64, blockTime uint64, statedb vm.StateDB) {
    // ... 现有代码 ...
    
    // 添加您的分叉检测
    if config.IsOnMyCustomUpgrade(blockNumber) {
        applySystemContractUpgrade(myCustomUpgrade[network], blockNumber, statedb, logger)
    }
}

5. 在 params/config.go 中添加分叉配置

// params/config.go

type ChainConfig struct {
    // ... 现有字段 ...
    
    // 添加您的自定义分叉字段
    MyCustomUpgradeBlock *big.Int `json:"myCustomUpgradeBlock,omitempty"`
}

// 添加分叉检测函数
func (c *ChainConfig) IsMyCustomUpgrade(num *big.Int) bool {
    return isBlockForked(c.MyCustomUpgradeBlock, num)
}

func (c *ChainConfig) IsOnMyCustomUpgrade(num *big.Int) bool {
    return configBlockEqual(c.MyCustomUpgradeBlock, num)
}

6. 字节码的加载机制

在 types.go 文件中，使用 Go 的 embed 指令来嵌入字节码文件：

 

// core/systemcontracts/ramanujan/types.go
package ramanujan

import _ "embed"

// contract codes for Chapel upgrade
var (
    //go:embed chapel/ValidatorContract
    ChapelValidatorContract string
    //go:embed chapel/SlashContract
    ChapelSlashContract string
    //go:embed chapel/SystemRewardContract
    ChapelSystemRewardContract string
    // ... 其他合约
)

// contract codes for Mainnet upgrade
var (
    //go:embed mainnet/ValidatorContract
    MainnetValidatorContract string
    // ... 其他合约
)

7. 在 genesis.json 中配置分叉高度

{
  "config": {
    "chainId": 1337,
    "homesteadBlock": 0,
    "eip150Block": 0,
    "eip155Block": 0,
    "eip158Block": 0,
    "byzantiumBlock": 0,
    "constantinopleBlock": 0,
    "petersburgBlock": 0,
    "istanbulBlock": 0,
    "muirGlacierBlock": 0,
    "berlinBlock": 0,
    "londonBlock": 0,
    "arrowGlacierBlock": 0,
    "grayGlacierBlock": 0,
    "mergeForkBlock": 0,
    "shanghaiTime": 0,
    "cancunTime": 0,
    "pragueTime": 0,
    
    // 🆕 添加您的自定义分叉配置
    "myCustomUpgradeBlock": 100000,  // 在区块高度 100000 触发升级
    
    "parlia": {
      "period": 3,
      "epoch": 200,
      "blockReward": "0x0000000000000000000000000000000000000000000000000000000000000000"
    }
  }
}

 

"eip150Block": 0, 这个就是去看高度

8. 重新编译和部署

# 重新编译
make clean && make

# 重启服务（数据完全保留）
docker-compose down
docker-compose up -d