refactor: remove upgrade* functions from system contracts

Enforce code-only upgrade principle: hardfork upgrades now only deploy
new contract bytecode without modifying on-chain state. State initialization
is restricted to v1 (genesis) only, preserving governance-modified values.

Author: 0xmhha

systemcontracts/coin_adapter.go

@@ -168,86 +168,3 @@ func initializeCoinAdapter(coinAdapterAddress common.Address, param map[string]s
 	return sp, nil
 }
 
-// upgradeCoinAdapter performs a migration-style upgrade for NativeCoinAdapter.
-// Only parameters present in param are written. Missing keys are skipped,
-// so existing on-chain values (masterMinter, name, symbol, etc.) are preserved.
-func upgradeCoinAdapter(coinAdapterAddress common.Address, param map[string]string) ([]params.StateParam, error) {
-	sp := make([]params.StateParam, 0)
-
-	if masterMinterStr, ok := param[COIN_ADAPTER_PARAM_MASTER_MINTER]; ok {
-		sp = append(sp, params.StateParam{
-			Address: coinAdapterAddress,
-			Key:     common.HexToHash(SLOT_COIN_ADAPTER_MASTER_MINTER),
-			Value:   common.BytesToHash(common.HexToAddress(masterMinterStr).Bytes()),
-		})
-	}
-
-	if mintersStr, ok := param[COIN_ADAPTER_PARAM_MINTERS]; ok && len(mintersStr) > 0 {
-		minters := splitAndTrim(mintersStr, ",")
-		minterAllowedAmounts := make([]*big.Int, len(minters))
-		if minterAllowedStr, ok := param[COIN_ADAPTER_PARAM_MINTER_ALLOWED]; ok && len(minterAllowedStr) > 0 {
-			minterAllowed := splitAndTrim(minterAllowedStr, ",")
-			if len(minters) != len(minterAllowed) {
-				return nil, fmt.Errorf("`systemContracts.nativeCoinAdapter.params`: the number of minters and minterAllowedAmounts must be the same")
-			}
-			for i, allowed := range minterAllowed {
-				allowedAmount, ok := new(big.Int).SetString(allowed, 10)
-				if !ok {
-					return nil, fmt.Errorf("`systemContracts.nativeCoinAdapter.params`: invalid minterAllowed, must be decimal")
-				}
-				minterAllowedAmounts[i] = allowedAmount
-			}
-		}
-		mintersSlot := common.HexToHash(SLOT_COIN_ADAPTER_MINTERS)
-		minterAllowedSlot := common.HexToHash(SLOT_COIN_ADAPTER_MINTER_ALLOWED)
-		for i, minter := range minters {
-			minterAddress := common.HexToAddress(minter)
-			sp = append(sp, params.StateParam{
-				Address: coinAdapterAddress,
-				Key:     CalculateMappingSlot(mintersSlot, minterAddress),
-				Value:   common.BytesToHash([]byte{1}),
-			})
-			if minterAllowedAmounts[i] != nil {
-				sp = append(sp, params.StateParam{
-					Address: coinAdapterAddress,
-					Key:     CalculateMappingSlot(minterAllowedSlot, minterAddress),
-					Value:   common.BigToHash(minterAllowedAmounts[i]),
-				})
-			}
-		}
-	}
-
-	if coinName, ok := param[COIN_ADAPTER_PARAM_NAME]; ok && len(coinName) > 0 {
-		for slot, value := range EncodeBytesToSlots(common.HexToHash(SLOT_COIN_ADAPTER_NAME), []byte(coinName)) {
-			sp = append(sp, params.StateParam{Address: coinAdapterAddress, Key: slot, Value: value})
-		}
-	}
-
-	if symbol, ok := param[COIN_ADAPTER_PARAM_SYMBOL]; ok && len(symbol) > 0 {
-		for slot, value := range EncodeBytesToSlots(common.HexToHash(SLOT_COIN_ADAPTER_SYMBOL), []byte(symbol)) {
-			sp = append(sp, params.StateParam{Address: coinAdapterAddress, Key: slot, Value: value})
-		}
-	}
-
-	if decimalsStr, ok := param[COIN_ADAPTER_PARAM_DECIMALS]; ok && len(decimalsStr) > 0 {
-		decimals, err := strconv.ParseUint(decimalsStr, 10, 8)
-		if err != nil {
-			return nil, fmt.Errorf("`systemContracts.nativeCoinAdapter.params.decimals`: %w", err)
-		}
-		sp = append(sp, params.StateParam{
-			Address: coinAdapterAddress,
-			Key:     common.HexToHash(SLOT_COIN_ADAPTER_DECIMALS),
-			Value:   common.BytesToHash([]byte{uint8(decimals)}),
-		})
-	}
-
-	if currency, ok := param[COIN_ADAPTER_PARAM_CURRENCY]; ok && len(currency) > 0 {
-		for slot, value := range EncodeBytesToSlots(common.HexToHash(SLOT_COIN_ADAPTER_CURRENCY), []byte(currency)) {
-			sp = append(sp, params.StateParam{Address: coinAdapterAddress, Key: slot, Value: value})
-		}
-	}
-
-	// totalSupply: never set during upgrade (runtime path has no alloc)
-
-	return sp, nil
-}

systemcontracts/gov_base.go

@@ -335,119 +335,3 @@ func initializeBase(govBaseAddress common.Address, param map[string]string) ([]p
 	return sp, nil
 }
 
-// upgradeBase performs a migration-style upgrade for GovBase storage.
-// Only parameters present in param are written to StateParam.
-// Missing keys are not appended, so state.SetState is never called for them,
-// preserving existing on-chain values automatically.
-func upgradeBase(govBaseAddress common.Address, param map[string]string) ([]params.StateParam, error) {
-	sp := make([]params.StateParam, 0)
-
-	if quorumStr, ok := param[GOV_BASE_PARAM_QUORUM]; ok {
-		quorum, err := strconv.ParseUint(quorumStr, 10, 64)
-		if err != nil {
-			return nil, fmt.Errorf("`systemContracts.govBase.params.quorum`: %w", err)
-		}
-		if quorum == 0 {
-			return nil, fmt.Errorf("`systemContracts.govBase.params.quorum` must be greater than 0")
-		}
-		sp = append(sp, params.StateParam{
-			Address: govBaseAddress,
-			Key:     common.HexToHash(SLOT_GOV_BASE_quorum),
-			Value:   common.BigToHash(big.NewInt(int64(quorum))),
-		})
-	}
-
-	if expiryStr, ok := param[GOV_BASE_PARAM_EXPIRY]; ok {
-		expiry, err := strconv.ParseUint(expiryStr, 10, 64)
-		if err != nil {
-			return nil, fmt.Errorf("`systemContracts.govBase.params.expiry`: %w", err)
-		}
-		sp = append(sp, params.StateParam{
-			Address: govBaseAddress,
-			Key:     common.HexToHash(SLOT_GOV_BASE_proposalExpiry),
-			Value:   common.BigToHash(big.NewInt(int64(expiry))),
-		})
-	}
-
-	if maxProposalsStr, ok := param[GOV_BASE_PARAM_MAX_PROPOSALS]; ok {
-		maxProposals, err := strconv.ParseUint(maxProposalsStr, 10, 64)
-		if err != nil {
-			return nil, fmt.Errorf("`systemContracts.govBase.params.maxProposals`: %w", err)
-		}
-		if maxProposals < 1 || maxProposals > 50 {
-			return nil, fmt.Errorf("`systemContracts.govBase.params.maxProposals` must be between 1 and 50, got %d", maxProposals)
-		}
-		sp = append(sp, params.StateParam{
-			Address: govBaseAddress,
-			Key:     common.HexToHash(SLOT_GOV_BASE_maxActiveProposalsPerMember),
-			Value:   common.BigToHash(big.NewInt(int64(maxProposals))),
-		})
-	}
-
-	// members: only process if explicitly provided. Mapping structures are preserved
-	// automatically when not appended.
-	if membersStr, ok := param[GOV_BASE_PARAM_MEMBERS]; ok {
-		memberAddresses := splitAndTrim(membersStr, ",")
-		uniqueMembers := make([]common.Address, 0)
-		seen := make(map[common.Address]struct{})
-		for _, addrStr := range memberAddresses {
-			member := common.HexToAddress(addrStr)
-			if member == (common.Address{}) {
-				return nil, fmt.Errorf("`systemContracts.govBase.params.members` contains invalid zero address")
-			}
-			if _, exists := seen[member]; !exists {
-				seen[member] = struct{}{}
-				uniqueMembers = append(uniqueMembers, member)
-			}
-		}
-
-		const MAX_MEMBERS = 255
-		if len(uniqueMembers) > MAX_MEMBERS {
-			return nil, fmt.Errorf("`systemContracts.govBase.params.members` count (%d) exceeds maximum allowed (%d)", len(uniqueMembers), MAX_MEMBERS)
-		}
-
-		versionStr, ok2 := param[GOV_BASE_PARAM_MEMBER_VERSION]
-		if !ok2 {
-			return nil, fmt.Errorf("`systemContracts.govBase.params.memberVersion` is required when `systemContracts.govBase.params.members` is set")
-		}
-		versionInt, err := strconv.ParseUint(versionStr, 10, 64)
-		if err != nil {
-			return nil, fmt.Errorf("`systemContracts.govBase.params.memberVersion`: %w", err)
-		}
-		version := new(big.Int).SetUint64(versionInt)
-
-		membersSlot := common.HexToHash(SLOT_GOV_BASE_members)
-		versionedMemberListSlot := common.HexToHash(SLOT_GOV_BASE_versionedMemberList)
-		versionSlot := common.HexToHash(SLOT_GOV_BASE_version)
-		memberIndexByVersionSlot := common.HexToHash(SLOT_GOV_BASE_memberIndexByVersion)
-		quorumByVersionSlot := common.HexToHash(SLOT_GOV_BASE_quorumByVersion)
-
-		memberData := Member{IsActive: true, JoinedAt: 0}.ToHash()
-		currentIdx := uint64(0)
-		for _, member := range uniqueMembers {
-			if currentIdx >= MAX_MEMBERS {
-				return nil, fmt.Errorf("member index overflow: currentIdx (%d) >= MAX_MEMBERS (%d)", currentIdx, MAX_MEMBERS)
-			}
-			sp = append(sp,
-				params.StateParam{Address: govBaseAddress, Key: CalculateMappingSlot(membersSlot, member), Value: memberData},
-				params.StateParam{Address: govBaseAddress, Key: CalculateDynamicSlot(CalculateMappingSlot(versionedMemberListSlot, version), new(big.Int).SetUint64(currentIdx)), Value: common.BytesToHash(member.Bytes())},
-				params.StateParam{Address: govBaseAddress, Key: CalculateMappingSlot(CalculateMappingSlot(memberIndexByVersionSlot, version), member), Value: common.BigToHash(new(big.Int).SetUint64(currentIdx + 1))},
-			)
-			currentIdx++
-		}
-		if currentIdx > 0 {
-			sp = append(sp, params.StateParam{Address: govBaseAddress, Key: CalculateMappingSlot(versionedMemberListSlot, version), Value: common.BigToHash(new(big.Int).SetUint64(currentIdx))})
-		}
-		sp = append(sp, params.StateParam{Address: govBaseAddress, Key: versionSlot, Value: common.BigToHash(version)})
-
-		// quorumByVersion: only if quorum was also provided
-		if quorumStr, ok := param[GOV_BASE_PARAM_QUORUM]; ok {
-			quorum, _ := strconv.ParseUint(quorumStr, 10, 64)
-			if quorum > 0 {
-				sp = append(sp, params.StateParam{Address: govBaseAddress, Key: CalculateMappingSlot(quorumByVersionSlot, version), Value: common.BigToHash(new(big.Int).SetUint64(quorum))})
-			}
-		}
-	}
-
-	return sp, nil
-}

systemcontracts/gov_base_test.go

@@ -25,8 +25,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 // CompareParam compares two StateParam objects for testing
@@ -575,59 +573,3 @@ func TestValidConfiguration(t *testing.T) {
 	}
 }
 
-// --- upgradeBase tests ---
-
-func TestUpgradeBase_EmptyParams(t *testing.T) {
-	sp, err := upgradeBase(common.HexToAddress("0x1003"), map[string]string{})
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(sp), "Empty params should produce no StateParams")
-}
-
-func TestUpgradeBase_AllParams(t *testing.T) {
-	addr := common.HexToAddress("0x1003")
-	sp, err := upgradeBase(addr, map[string]string{
-		"quorum":       "4",
-		"expiry":       "86400",
-		"maxProposals": "10",
-	})
-	require.NoError(t, err)
-	assert.Equal(t, 3, len(sp), "Should have exactly 3 StateParams")
-
-	quorumParam := findStateParam(sp, common.HexToHash(SLOT_GOV_BASE_quorum))
-	require.NotNil(t, quorumParam)
-	assert.Equal(t, common.BigToHash(big.NewInt(4)), quorumParam.Value)
-
-	expiryParam := findStateParam(sp, common.HexToHash(SLOT_GOV_BASE_proposalExpiry))
-	require.NotNil(t, expiryParam)
-	assert.Equal(t, common.BigToHash(big.NewInt(86400)), expiryParam.Value)
-
-	maxProposalsParam := findStateParam(sp, common.HexToHash(SLOT_GOV_BASE_maxActiveProposalsPerMember))
-	require.NotNil(t, maxProposalsParam)
-	assert.Equal(t, common.BigToHash(big.NewInt(10)), maxProposalsParam.Value)
-}
-
-func TestUpgradeBase_InvalidQuorum(t *testing.T) {
-	_, err := upgradeBase(common.HexToAddress("0x1003"), map[string]string{"quorum": "0"})
-	assert.Error(t, err, "quorum=0 should be rejected")
-}
-
-func TestUpgradeBase_InvalidMaxProposals(t *testing.T) {
-	_, err := upgradeBase(common.HexToAddress("0x1003"), map[string]string{"maxProposals": "51"})
-	assert.Error(t, err, "maxProposals=51 should be rejected (max 50)")
-}
-
-func TestUpgradeBase_MembersWithVersion(t *testing.T) {
-	sp, err := upgradeBase(common.HexToAddress("0x1003"), map[string]string{
-		"members":       "0xaa5faa65e9cc0f74a85b6fdfb5f6991f5c094697",
-		"memberVersion": "2",
-	})
-	require.NoError(t, err)
-	assert.True(t, len(sp) > 0, "Should produce member-related StateParams")
-}
-
-func TestUpgradeBase_MembersWithoutVersion(t *testing.T) {
-	_, err := upgradeBase(common.HexToAddress("0x1003"), map[string]string{
-		"members": "0xaa5faa65e9cc0f74a85b6fdfb5f6991f5c094697",
-	})
-	assert.Error(t, err, "members without memberVersion should fail")
-}

systemcontracts/gov_council.go

@@ -108,44 +108,6 @@ func initializeGovCouncil(govCouncilAddress common.Address, param map[string]str
 	return sp, nil
 }
 
-// upgradeGovCouncil performs a migration-style upgrade for GovCouncil.
-// Only parameters present in param are written. Missing keys are skipped.
-func upgradeGovCouncil(govCouncilAddress common.Address, param map[string]string) ([]params.StateParam, error) {
-	sp, err := upgradeBase(govCouncilAddress, param)
-	if err != nil {
-		return nil, err
-	}
-
-	if blacklistStr, ok := param[GOV_COUNCIL_PARAM_BLACKLIST]; ok && blacklistStr != "" {
-		blacklistAddresses := splitAndTrim(blacklistStr, ",")
-		blacklistParams, err := initializeAddressSet(
-			govCouncilAddress,
-			common.HexToHash(SLOT_GOV_COUNCIL_currentBlacklist_values),
-			common.HexToHash(SLOT_GOV_COUNCIL_currentBlacklist_positions),
-			blacklistAddresses, "blacklist",
-		)
-		if err != nil {
-			return nil, fmt.Errorf("`systemContracts.govCouncil.params.blacklist`: %w", err)
-		}
-		sp = append(sp, blacklistParams...)
-	}
-
-	if authorizedAccountsStr, ok := param[GOV_COUNCIL_PARAM_AUTHORIZED_ACCOUNTS]; ok && authorizedAccountsStr != "" {
-		authorizedAccountAddresses := splitAndTrim(authorizedAccountsStr, ",")
-		authorizedAccountParams, err := initializeAddressSet(
-			govCouncilAddress,
-			common.HexToHash(SLOT_GOV_COUNCIL_currentAuthorizedAccounts_values),
-			common.HexToHash(SLOT_GOV_COUNCIL_currentAuthorizedAccounts_positions),
-			authorizedAccountAddresses, "authorizedAccounts",
-		)
-		if err != nil {
-			return nil, fmt.Errorf("`systemContracts.govCouncil.params.authorizedAccounts`: %w", err)
-		}
-		sp = append(sp, authorizedAccountParams...)
-	}
-
-	return sp, nil
-}
 
 // initializeAddressSet initializes an AddressSet storage structure
 // Follows AddressSetLib.sol implementation: