revert PR 156 (#161)

Author: bytesizedroll

.changeset/fancy-ducks-greet.md

@@ -0,0 +1,5 @@
+---
+"chainlink-deployments-framework": patch
+---
+
+Revert PR 156 as not needed in CLDF

deployment/address_book.go

@@ -1,10 +1,8 @@
 package deployment
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
-	"sort"
 	"strings"
 	"sync"
 
@@ -128,80 +126,6 @@ type OrderedAddressEntry struct {
 	TypeAndVersion TypeAndVersion `json:"typeAndVersion"`
 }
 
-// MarshalJSON implements custom JSON marshaling for AddressesByChain
-// to ensure deterministic ordering: chain selectors numerically, addresses alphabetically (case-insensitive)
-func (abc AddressesByChain) MarshalJSON() ([]byte, error) {
-	// Get all chain selectors and sort them numerically
-	chainSelectors := make([]uint64, 0, len(abc))
-	for chainSelector := range abc {
-		chainSelectors = append(chainSelectors, chainSelector)
-	}
-	sort.Slice(chainSelectors, func(i, j int) bool {
-		return chainSelectors[i] < chainSelectors[j]
-	})
-
-	// Build ordered result
-	result := make([]OrderedChain, 0, len(chainSelectors))
-
-	for _, chainSelector := range chainSelectors {
-		chainAddresses := abc[chainSelector]
-
-		// Get all addresses and sort them alphabetically
-		addresses := make([]string, 0, len(chainAddresses))
-		for address := range chainAddresses {
-			addresses = append(addresses, address)
-		}
-		sort.Slice(addresses, func(i, j int) bool {
-			return strings.ToLower(addresses[i]) < strings.ToLower(addresses[j]) // Using ToLower to ensure case-insensitive sorting
-		})
-
-		// Build ordered address entries
-		orderedAddresses := make([]OrderedAddressEntry, 0, len(addresses))
-		for _, address := range addresses {
-			orderedAddresses = append(orderedAddresses, OrderedAddressEntry{
-				Address:        address,
-				TypeAndVersion: chainAddresses[address],
-			})
-		}
-
-		result = append(result, OrderedChain{
-			ChainSelector: chainSelector,
-			Addresses:     orderedAddresses,
-		})
-	}
-
-	return json.Marshal(result)
-}
-
-// UnmarshalJSON implements custom JSON unmarshaling for AddressesByChain
-func (abc *AddressesByChain) UnmarshalJSON(data []byte) error {
-	var orderedChains []OrderedChain
-	if err := json.Unmarshal(data, &orderedChains); err != nil {
-		return err
-	}
-
-	// Initialize the map if it's nil
-	if *abc == nil {
-		*abc = make(AddressesByChain)
-	}
-
-	// Convert back to map structure
-	for _, chain := range orderedChains {
-		chainAddresses := make(map[string]TypeAndVersion)
-		for _, addrEntry := range chain.Addresses {
-			tv := addrEntry.TypeAndVersion
-			// Ensure LabelSet is properly initialized if nil
-			if tv.Labels == nil {
-				tv.Labels = make(LabelSet)
-			}
-			chainAddresses[addrEntry.Address] = tv
-		}
-		(*abc)[chain.ChainSelector] = chainAddresses
-	}
-
-	return nil
-}
-
 type AddressBookMap struct {
 	addressesByChain AddressesByChain
 	mtx              sync.RWMutex
@@ -445,27 +369,3 @@ func (tv *TypeAndVersion) AddLabel(label string) {
 	}
 	tv.Labels.Add(label)
 }
-
-// MarshalJSON implements custom JSON marshaling for AddressBookMap
-// to ensure deterministic ordering via the AddressesByChain marshaling
-func (m *AddressBookMap) MarshalJSON() ([]byte, error) {
-	m.mtx.RLock()
-	defer m.mtx.RUnlock()
-
-	// Use the custom marshaling of AddressesByChain
-	return json.Marshal(m.addressesByChain)
-}
-
-// UnmarshalJSON implements custom JSON unmarshaling for AddressBookMap
-func (m *AddressBookMap) UnmarshalJSON(data []byte) error {
-	m.mtx.Lock()
-	defer m.mtx.Unlock()
-
-	// Initialize if needed
-	if m.addressesByChain == nil {
-		m.addressesByChain = make(AddressesByChain)
-	}
-
-	// Use the custom unmarshaling of AddressesByChain
-	return json.Unmarshal(data, &m.addressesByChain)
-}

deployment/address_book_test.go

@@ -1,10 +1,7 @@
 package deployment
 
 import (
-	"encoding/json"
 	"math/big"
-	"strconv"
-	"strings"
 	"sync"
 	"testing"
 
@@ -574,130 +571,3 @@ func Test_toTypeAndVersionMap(t *testing.T) {
 		})
 	}
 }
-
-func TestAddressBookMap_JSONMarshaling(t *testing.T) {
-	t.Parallel()
-
-	// Create test data with multiple chains and addresses
-	onRamp100 := NewTypeAndVersion("OnRamp", Version1_0_0)
-	onRamp110 := NewTypeAndVersion("OnRamp", Version1_1_0)
-
-	// Create addresses in non-alphabetical order
-	addr1 := common.HexToAddress("0xC").String() // Will be third
-	addr2 := common.HexToAddress("0xA").String() // Will be first
-	addr3 := common.HexToAddress("0xB").String() // Will be second
-
-	// Create address book with chains in non-numerical order
-	originalAB := NewMemoryAddressBookFromMap(map[uint64]map[string]TypeAndVersion{
-		chainsel.TEST_90000002.Selector: { // Higher chain selector
-			addr1: onRamp100,
-			addr2: onRamp110,
-		},
-		chainsel.TEST_90000001.Selector: { // Lower chain selector
-			addr3: onRamp100,
-			addr1: onRamp110,
-		},
-	})
-
-	// Marshal to JSON twice
-	jsonData1, err := json.Marshal(originalAB)
-	require.NoError(t, err)
-
-	jsonData2, err := json.Marshal(originalAB)
-	require.NoError(t, err)
-
-	// Convert to strings for comparison
-	jsonStr1 := string(jsonData1)
-	jsonStr2 := string(jsonData2)
-
-	// All JSON strings should be exactly identical
-	assert.JSONEq(t, jsonStr1, jsonStr2, "First and second marshal should produce identical JSON strings")
-
-	// Test with pretty-printed JSON to show structure more clearly
-	prettyJSON1, err := json.MarshalIndent(originalAB, "", "  ")
-	require.NoError(t, err)
-
-	prettyJSON2, err := json.MarshalIndent(originalAB, "", "  ")
-	require.NoError(t, err)
-
-	assert.Equal(t, string(prettyJSON1), string(prettyJSON2), "Pretty-printed JSON should also be deterministic") //nolint:testifylint
-
-	// Unmarshal back to verify that works
-	var unmarshaledAB AddressBookMap
-	err = json.Unmarshal(jsonData1, &unmarshaledAB)
-	require.NoError(t, err)
-
-	// Verify the data is there
-	addresses, err := unmarshaledAB.Addresses()
-	require.NoError(t, err)
-
-	originalAddresses, err := originalAB.Addresses()
-	require.NoError(t, err)
-
-	assert.Equal(t, originalAddresses, addresses)
-
-	// Verify the ordering is correct by checking chain selector positions
-	chain1Str := strconv.FormatUint(chainsel.TEST_90000001.Selector, 10)
-	chain2Str := strconv.FormatUint(chainsel.TEST_90000002.Selector, 10)
-
-	chain1Pos := strings.Index(jsonStr1, chain1Str)
-	chain2Pos := strings.Index(jsonStr1, chain2Str)
-
-	// Verify the smaller chain selector comes first
-	if chainsel.TEST_90000001.Selector < chainsel.TEST_90000002.Selector {
-		assert.Greater(t, chain2Pos, chain1Pos, "Chain selectors should be ordered numerically")
-	} else {
-		assert.Greater(t, chain1Pos, chain2Pos, "Chain selectors should be ordered numerically")
-	}
-
-	// Test exact expected output string
-	expectedJSON := `[{"chainSelector":909606746561742123,"addresses":[{"address":"0x000000000000000000000000000000000000000b","typeAndVersion":{"Type":"OnRamp","Version":"1.0.0"}},{"address":"0x000000000000000000000000000000000000000C","typeAndVersion":{"Type":"OnRamp","Version":"1.1.0"}}]},{"chainSelector":5548718428018410741,"addresses":[{"address":"0x000000000000000000000000000000000000000A","typeAndVersion":{"Type":"OnRamp","Version":"1.1.0"}},{"address":"0x000000000000000000000000000000000000000C","typeAndVersion":{"Type":"OnRamp","Version":"1.0.0"}}]}]`
-
-	assert.Equal(t, expectedJSON, jsonStr1, "JSON should match exact expected deterministic output") //nolint:testifylint
-}
-
-func TestAddressesByChain_JSONMarshaling(t *testing.T) {
-	t.Parallel()
-
-	// Test the AddressesByChain type directly
-	onRamp100 := NewTypeAndVersion("OnRamp", Version1_0_0)
-	addr1 := common.HexToAddress("0x3a").String()
-	addr2 := common.HexToAddress("0x1b").String()
-
-	abc := AddressesByChain{
-		chainsel.TEST_90000002.Selector: {
-			addr1: onRamp100,
-			addr2: onRamp100,
-		},
-		chainsel.TEST_90000001.Selector: {
-			addr1: onRamp100,
-		},
-	}
-
-	// Marshal multiple times
-	jsonData1, err := json.Marshal(abc)
-	require.NoError(t, err)
-
-	jsonData2, err := json.Marshal(abc)
-	require.NoError(t, err)
-
-	// Convert to strings for exact comparison
-	jsonStr1 := string(jsonData1)
-	jsonStr2 := string(jsonData2)
-
-	// All should be exactly equal
-	assert.Equal(t, jsonStr1, jsonStr2, "Multiple marshal operations should produce identical strings") //nolint:testifylint
-
-	// Unmarshal and verify
-	var unmarshaled AddressesByChain
-	err = json.Unmarshal(jsonData1, &unmarshaled)
-	require.NoError(t, err)
-
-	// Should be equal to original
-	assert.Equal(t, abc, unmarshaled)
-
-	// Test exact expected output string
-	expectedJSON := `[{"chainSelector":909606746561742123,"addresses":[{"address":"0x000000000000000000000000000000000000003a","typeAndVersion":{"Type":"OnRamp","Version":"1.0.0"}}]},{"chainSelector":5548718428018410741,"addresses":[{"address":"0x000000000000000000000000000000000000001B","typeAndVersion":{"Type":"OnRamp","Version":"1.0.0"}},{"address":"0x000000000000000000000000000000000000003a","typeAndVersion":{"Type":"OnRamp","Version":"1.0.0"}}]}]`
-
-	assert.Equal(t, expectedJSON, jsonStr1, "JSON should match exact expected deterministic output") //nolint:testifylint
-}