Introduce ShortNodeID

genesis/config.go

@@ -65,7 +65,7 @@ func (a Allocation) Compare(other Allocation) int {
 }
 
 type Staker struct {
-	NodeID        ids.NodeID                `json:"nodeID"`
+	NodeID        ids.ShortNodeID           `json:"nodeID"`
 	RewardAddress ids.ShortID               `json:"rewardAddress"`
 	DelegationFee uint32                    `json:"delegationFee"`
 	Signer        *signer.ProofOfPossession `json:"signer,omitempty"`

genesis/unparsed_config.go

@@ -55,7 +55,7 @@ func (ua UnparsedAllocation) Parse() (Allocation, error) {
 }
 
 type UnparsedStaker struct {
-	NodeID        ids.NodeID                `json:"nodeID"`
+	NodeID        ids.ShortNodeID           `json:"nodeID"`
 	RewardAddress string                    `json:"rewardAddress"`
 	DelegationFee uint32                    `json:"delegationFee"`
 	Signer        *signer.ProofOfPossession `json:"signer,omitempty"`

ids/node_id.go

@@ -4,89 +4,51 @@
 package ids
 
 import (
-	"bytes"
 	"errors"
-	"fmt"
 
-	"github.com/ava-labs/avalanchego/staking"
 	"github.com/ava-labs/avalanchego/utils"
-	"github.com/ava-labs/avalanchego/utils/hashing"
 )
 
 const (
 	NodeIDPrefix = "NodeID-"
-	NodeIDLen    = ShortIDLen
+	NodeIDLen    = ShortIDLen // this would eventually be updated to 32 byte length.
 )
 
 var (
 	EmptyNodeID = NodeID{}
 
-	errShortNodeID = errors.New("insufficient NodeID length")
-
 	_ utils.Sortable[NodeID] = NodeID{}
-)
 
-type NodeID ShortID
-
-func (id NodeID) String() string {
-	return ShortID(id).PrefixedString(NodeIDPrefix)
-}
-
-func (id NodeID) Bytes() []byte {
-	return id[:]
-}
+	errWrongNodeIDLength = errors.New("wrong NodeID length")
+)
 
-func (id NodeID) MarshalJSON() ([]byte, error) {
-	return []byte(`"` + id.String() + `"`), nil
+type NodeID struct {
+	ShortNodeID `serialize:"true"`
 }
 
-func (id NodeID) MarshalText() ([]byte, error) {
-	return []byte(id.String()), nil
+func (id NodeID) Compare(other NodeID) int {
+	return id.ShortNodeID.Compare(other.ShortNodeID)
 }
 
-func (id *NodeID) UnmarshalJSON(b []byte) error {
-	str := string(b)
-	if str == nullStr { // If "null", do nothing
-		return nil
-	} else if len(str) <= 2+len(NodeIDPrefix) {
-		return fmt.Errorf("%w: expected to be > %d", errShortNodeID, 2+len(NodeIDPrefix))
-	}
-
-	lastIndex := len(str) - 1
-	if str[0] != '"' || str[lastIndex] != '"' {
-		return errMissingQuotes
+// NodeIDFromString is the inverse of NodeID.String()
+func NodeIDFromString(nodeIDStr string) (NodeID, error) {
+	asShort, err := ShortFromPrefixedString(nodeIDStr, NodeIDPrefix)
+	if err != nil {
+		return NodeID{}, err
 	}
-
-	var err error
-	*id, err = NodeIDFromString(str[1:lastIndex])
-	return err
-}
-
-func (id *NodeID) UnmarshalText(text []byte) error {
-	return id.UnmarshalJSON(text)
-}
-
-func (id NodeID) Compare(other NodeID) int {
-	return bytes.Compare(id[:], other[:])
+	return NodeID{ShortNodeID: ShortNodeID(asShort)}, nil
 }
 
-// ToNodeID attempt to convert a byte slice into a node id
 func ToNodeID(bytes []byte) (NodeID, error) {
 	nodeID, err := ToShortID(bytes)
-	return NodeID(nodeID), err
+	return NodeID{ShortNodeID: ShortNodeID(nodeID)}, err
 }
 
-func NodeIDFromCert(cert *staking.Certificate) NodeID {
-	return hashing.ComputeHash160Array(
-		hashing.ComputeHash256(cert.Raw),
-	)
-}
-
-// NodeIDFromString is the inverse of NodeID.String()
-func NodeIDFromString(nodeIDStr string) (NodeID, error) {
-	asShort, err := ShortFromPrefixedString(nodeIDStr, NodeIDPrefix)
-	if err != nil {
-		return NodeID{}, err
+func ParseNodeID(bytes []byte) (NodeID, error) {
+	if len(bytes) == ShortIDLen {
+		var node NodeID
+		copy(node.ShortNodeID[:], bytes)
+		return node, nil
 	}
-	return NodeID(asShort), nil
+	return NodeID{}, errWrongNodeIDLength
 }

ids/node_id_test.go

@@ -16,8 +16,8 @@ import (
 func TestNodeIDEquality(t *testing.T) {
 	require := require.New(t)
 
-	id := NodeID{24}
-	idCopy := NodeID{24}
+	id := NodeID{ShortNodeID: ShortNodeID{24}}
+	idCopy := NodeID{ShortNodeID: ShortNodeID{24}}
 	require.Equal(id, idCopy)
 	id2 := NodeID{}
 	require.NotEqual(id, id2)
@@ -26,7 +26,7 @@ func TestNodeIDEquality(t *testing.T) {
 func TestNodeIDFromString(t *testing.T) {
 	require := require.New(t)
 
-	id := NodeID{'a', 'v', 'a', ' ', 'l', 'a', 'b', 's'}
+	id := NodeID{ShortNodeID: ShortNodeID{'a', 'v', 'a', ' ', 'l', 'a', 'b', 's'}}
 	idStr := id.String()
 	id2, err := NodeIDFromString(idStr)
 	require.NoError(err)
@@ -76,7 +76,7 @@ func TestNodeIDMarshalJSON(t *testing.T) {
 		},
 		{
 			`ID("ava labs")`,
-			NodeID{'a', 'v', 'a', ' ', 'l', 'a', 'b', 's'},
+			NodeID{ShortNodeID: ShortNodeID{'a', 'v', 'a', ' ', 'l', 'a', 'b', 's'}},
 			[]byte(`"NodeID-9tLMkeWFhWXd8QZc4rSiS5meuVXF5kRsz"`),
 			nil,
 		},
@@ -108,7 +108,7 @@ func TestNodeIDUnmarshalJSON(t *testing.T) {
 		{
 			`NodeID("ava labs")`,
 			[]byte(`"NodeID-9tLMkeWFhWXd8QZc4rSiS5meuVXF5kRsz"`),
-			NodeID{'a', 'v', 'a', ' ', 'l', 'a', 'b', 's'},
+			NodeID{ShortNodeID: ShortNodeID{'a', 'v', 'a', ' ', 'l', 'a', 'b', 's'}},
 			nil,
 		},
 		{
@@ -161,7 +161,7 @@ func TestNodeIDString(t *testing.T) {
 		expected string
 	}{
 		{"NodeID{}", NodeID{}, "NodeID-111111111111111111116DBWJs"},
-		{"NodeID{24}", NodeID{24}, "NodeID-3BuDc2d1Efme5Apba6SJ8w3Tz7qeh6mHt"},
+		{"NodeID{24}", NodeID{ShortNodeID: ShortNodeID{24}}, "NodeID-3BuDc2d1Efme5Apba6SJ8w3Tz7qeh6mHt"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.label, func(t *testing.T) {
@@ -174,8 +174,8 @@ func TestNodeIDMapMarshalling(t *testing.T) {
 	require := require.New(t)
 
 	originalMap := map[NodeID]int{
-		{'e', 'v', 'a', ' ', 'l', 'a', 'b', 's'}: 1,
-		{'a', 'v', 'a', ' ', 'l', 'a', 'b', 's'}: 2,
+		{ShortNodeID: ShortNodeID{'a', 'v', 'a', ' ', 'l', 'a', 'b', 's'}}: 1,
+		{ShortNodeID: ShortNodeID{'a', 'v', 'a', ' ', 'l', 'a', 'b', 's'}}: 2,
 	}
 	mapJSON, err := json.Marshal(originalMap)
 	require.NoError(err)
@@ -192,18 +192,18 @@ func TestNodeIDCompare(t *testing.T) {
 		expected int
 	}{
 		{
-			a:        NodeID{1},
-			b:        NodeID{0},
+			a:        NodeID{ShortNodeID: ShortNodeID{1}},
+			b:        NodeID{ShortNodeID: ShortNodeID{0}},
 			expected: 1,
 		},
 		{
-			a:        NodeID{1},
-			b:        NodeID{1},
+			a:        NodeID{ShortNodeID: ShortNodeID{1}},
+			b:        NodeID{ShortNodeID: ShortNodeID{1}},
 			expected: 0,
 		},
 		{
-			a:        NodeID{1, 0},
-			b:        NodeID{1, 2},
+			a:        NodeID{ShortNodeID: ShortNodeID{1, 0}},
+			b:        NodeID{ShortNodeID: ShortNodeID{1, 2}},
 			expected: -1,
 		},
 	}

ids/short_node_id.go

@@ -0,0 +1,104 @@
+// Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package ids
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+
+	"github.com/ava-labs/avalanchego/staking"
+	"github.com/ava-labs/avalanchego/utils"
+	"github.com/ava-labs/avalanchego/utils/hashing"
+)
+
+const ShortNodeIDLen = ShortIDLen
+
+var (
+	EmptyShortNodeID = ShortNodeID{}
+
+	errShortNodeID = errors.New("insufficient ShortNodeID length")
+
+	_ utils.Sortable[ShortNodeID] = ShortNodeID{}
+)
+
+type ShortNodeID ShortID
+
+func (sn ShortNodeID) Bytes() []byte {
+	return sn[:]
+}
+
+func ToShortNodeID(bytes []byte) (ShortNodeID, error) {
+	nodeID, err := ToShortID(bytes)
+	return ShortNodeID(nodeID), err
+}
+
+func (sn ShortNodeID) String() string {
+	return ShortID(sn).PrefixedString(NodeIDPrefix)
+}
+
+// ShortNodeIDFromString is the inverse of ShortNodeID.String()
+func ShortNodeIDFromString(nodeIDStr string) (ShortNodeID, error) {
+	asShort, err := ShortFromPrefixedString(nodeIDStr, NodeIDPrefix)
+	if err != nil {
+		return EmptyShortNodeID, err
+	}
+	return ShortNodeID(asShort), nil
+}
+
+// ShortNodeIDFromNodeID is the inverse of NodeID.String()
+func ShortNodeIDFromNodeID(nodeID NodeID) (ShortNodeID, error) {
+	if nodeID == EmptyNodeID {
+		return EmptyShortNodeID, nil
+	}
+	res, err := ToShortNodeID(nodeID.Bytes())
+	if err != nil {
+		return EmptyShortNodeID, fmt.Errorf("failed converting NodeID to ShortNodeID, %w", err)
+	}
+	return res, nil
+}
+
+func (sn ShortNodeID) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + sn.String() + `"`), nil
+}
+
+func (sn *ShortNodeID) UnmarshalJSON(b []byte) error {
+	str := string(b)
+	if str == nullStr { // If "null", do nothing
+		return nil
+	} else if len(str) <= 2+len(NodeIDPrefix) {
+		return fmt.Errorf("%w: expected to be > %d", errShortNodeID, 2+len(NodeIDPrefix))
+	}
+
+	lastIndex := len(str) - 1
+	if str[0] != '"' || str[lastIndex] != '"' {
+		return errMissingQuotes
+	}
+
+	var err error
+	*sn, err = ShortNodeIDFromString(str[1:lastIndex])
+	return err
+}
+
+func (sn ShortNodeID) MarshalText() ([]byte, error) {
+	return []byte(sn.String()), nil
+}
+
+func (sn *ShortNodeID) UnmarshalText(text []byte) error {
+	return sn.UnmarshalJSON(text)
+}
+
+func (sn ShortNodeID) Compare(other ShortNodeID) int {
+	return bytes.Compare(sn[:], other[:])
+}
+
+func (sn ShortNodeID) NodeID() NodeID {
+	return NodeID{ShortNodeID: sn}
+}
+
+func ShortNodeIDFromCert(cert *staking.Certificate) ShortNodeID {
+	return hashing.ComputeHash160Array(
+		hashing.ComputeHash256(cert.Raw),
+	)
+}