Implement rhp4 basic client and server

chain/chain_test.go

@@ -7,6 +7,7 @@ import (
 	"go.sia.tech/core/types"
 	"go.sia.tech/coreutils"
 	"go.sia.tech/coreutils/chain"
+	"go.sia.tech/coreutils/testutil"
 	"lukechampine.com/frand"
 )
 
@@ -113,11 +114,7 @@ func newMemState() *memState {
 }
 
 func TestV2Attestations(t *testing.T) {
-	n, genesisBlock := chain.TestnetZen()
-
-	n.InitialTarget = types.BlockID{0xFF}
-	n.HardforkV2.AllowHeight = 2
-	n.HardforkV2.RequireHeight = 3
+	n, genesisBlock := testutil.V2Network()
 
 	policy := types.AnyoneCanSpend()
 	addr := policy.Address()
@@ -144,7 +141,7 @@ func TestV2Attestations(t *testing.T) {
 		ms := newMemState()
 
 		// mine until a utxo is spendable
-		mineBlocks(t, cm, 150)
+		mineBlocks(t, cm, int(n.MaturityDelay)+1)
 		ms.Sync(t, cm)
 
 		txn := types.V2Transaction{
@@ -179,13 +176,12 @@ func TestV2Attestations(t *testing.T) {
 		ms := newMemState()
 
 		// mine until a utxo is spendable
-		mineBlocks(t, cm, 150)
+		mineBlocks(t, cm, int(n.MaturityDelay)+1)
 		ms.Sync(t, cm)
 
 		sk := types.GeneratePrivateKey()
-		ann := chain.HostAnnouncement{
-			NetAddress: "foo.bar:1234",
-			PublicKey:  sk.PublicKey(),
+		ann := chain.V2HostAnnouncement{
+			{Address: "foo.bar:1234", Protocol: "tcp"},
 		}
 		se := ms.SpendableElement(t)
 		txn := types.V2Transaction{
@@ -229,13 +225,12 @@ func TestV2Attestations(t *testing.T) {
 		ms := newMemState()
 
 		// mine until a utxo is spendable
-		mineBlocks(t, cm, 150)
+		mineBlocks(t, cm, int(n.MaturityDelay)+1)
 		ms.Sync(t, cm)
 
 		sk := types.GeneratePrivateKey()
-		ann := chain.HostAnnouncement{
-			NetAddress: "foo.bar:1234",
-			PublicKey:  sk.PublicKey(),
+		ann := chain.V2HostAnnouncement{
+			{Address: "foo.bar:1234", Protocol: "tcp"},
 		}
 		txn := types.V2Transaction{
 			ArbitraryData: frand.Bytes(16),
@@ -274,13 +269,12 @@ func TestV2Attestations(t *testing.T) {
 		ms := newMemState()
 
 		// mine until a utxo is spendable
-		mineBlocks(t, cm, 150)
+		mineBlocks(t, cm, int(n.MaturityDelay)+1)
 		ms.Sync(t, cm)
 
 		sk := types.GeneratePrivateKey()
-		ann := chain.HostAnnouncement{
-			NetAddress: "foo.bar:1234",
-			PublicKey:  sk.PublicKey(),
+		ann := chain.V2HostAnnouncement{
+			{Address: "foo.bar:1234", Protocol: "tcp"},
 		}
 		se := ms.SpendableElement(t)
 		minerFee := types.Siacoins(1)

chain/hostannouncement.go

@@ -2,6 +2,7 @@ package chain
 
 import (
 	"bytes"
+	"errors"
 
 	"go.sia.tech/core/consensus"
 	"go.sia.tech/core/types"
@@ -11,36 +12,66 @@ const attestationHostAnnouncement = "HostAnnouncement"
 
 var specifierHostAnnouncement = types.NewSpecifier("HostAnnouncement")
 
-// A HostAnnouncement represents a signed announcement of a host's network
-// address. Announcements may be made via arbitrary data (in a v1 transaction)
-// or via attestation (in a v2 transaction).
-type HostAnnouncement struct {
-	PublicKey  types.PublicKey `json:"publicKey"`
-	NetAddress string          `json:"netAddress"`
+type (
+	// A HostAnnouncement represents a signed announcement of a host's network
+	// address. Announcements may be made via arbitrary data (in a v1 transaction)
+	// or via attestation (in a v2 transaction).
+	HostAnnouncement struct {
+		PublicKey  types.PublicKey `json:"publicKey"`
+		NetAddress string          `json:"netAddress"`
+	}
+
+	// A Protocol is a string identifying a network protocol that a host may be
+	// reached on.
+	Protocol string
+
+	// A NetAddress is a pair of protocol and address that a host may be reached on
+	NetAddress struct {
+		Protocol Protocol `json:"protocol"`
+		Address  string   `json:"address"`
+	}
+
+	// A V2HostAnnouncement lists all the network addresses a host may be reached on
+	V2HostAnnouncement []NetAddress
+)
+
+// EncodeTo implements types.EncoderTo.
+func (na NetAddress) EncodeTo(e *types.Encoder) {
+	e.WriteString(string(na.Protocol))
+	e.WriteString(na.Address)
+}
+
+// DecodeFrom implements types.DecoderFrom.
+func (na *NetAddress) DecodeFrom(d *types.Decoder) {
+	na.Protocol = Protocol(d.ReadString())
+	na.Address = d.ReadString()
 }
 
 // ToAttestation encodes a host announcement as an attestation.
-func (ha HostAnnouncement) ToAttestation(cs consensus.State, sk types.PrivateKey) types.Attestation {
-	if ha.PublicKey != sk.PublicKey() {
-		panic("key mismatch") // developer error
+func (ha V2HostAnnouncement) ToAttestation(cs consensus.State, sk types.PrivateKey) types.Attestation {
+	buf := bytes.NewBuffer(nil)
+	e := types.NewEncoder(buf)
+	types.EncodeSlice(e, ha)
+	if err := e.Flush(); err != nil {
+		panic(err) // should never happen
 	}
 	a := types.Attestation{
-		PublicKey: ha.PublicKey,
+		PublicKey: sk.PublicKey(),
 		Key:       attestationHostAnnouncement,
-		Value:     []byte(ha.NetAddress),
+		Value:     buf.Bytes(),
 	}
 	a.Signature = sk.SignHash(cs.AttestationSigHash(a))
 	return a
 }
 
 // FromAttestation decodes a host announcement from an attestation.
-func (ha *HostAnnouncement) FromAttestation(a types.Attestation) bool {
+func (ha *V2HostAnnouncement) FromAttestation(a types.Attestation) error {
 	if a.Key != attestationHostAnnouncement {
-		return false
+		return errors.New("not a host announcement")
 	}
-	ha.PublicKey = a.PublicKey
-	ha.NetAddress = string(a.Value)
-	return true
+	d := types.NewBufDecoder(a.Value)
+	types.DecodeSlice(d, (*[]NetAddress)(ha))
+	return d.Err()
 }
 
 // ToArbitraryData encodes a host announcement as arbitrary data.
@@ -93,11 +124,15 @@ func ForEachHostAnnouncement(b types.Block, fn func(HostAnnouncement)) {
 			}
 		}
 	}
+}
+
+// ForEachV2HostAnnouncement calls fn on each v2 host announcement in a block.
+func ForEachV2HostAnnouncement(b types.Block, fn func(types.PublicKey, []NetAddress)) {
 	for _, txn := range b.V2Transactions() {
 		for _, a := range txn.Attestations {
-			var ha HostAnnouncement
-			if ha.FromAttestation(a) {
-				fn(ha)
+			var ha V2HostAnnouncement
+			if err := ha.FromAttestation(a); err == nil {
+				fn(a.PublicKey, ha)
 			}
 		}
 	}

chain/hostannouncement_test.go

@@ -1,10 +1,13 @@
 package chain
 
 import (
+	"encoding/binary"
+	"math"
 	"testing"
 
 	"go.sia.tech/core/consensus"
 	"go.sia.tech/core/types"
+	"lukechampine.com/frand"
 )
 
 func TestForEachHostAnnouncement(t *testing.T) {
@@ -17,11 +20,6 @@ func TestForEachHostAnnouncement(t *testing.T) {
 		Transactions: []types.Transaction{
 			{ArbitraryData: [][]byte{ha.ToArbitraryData(sk)}},
 		},
-		V2: &types.V2BlockData{
-			Transactions: []types.V2Transaction{
-				{Attestations: []types.Attestation{ha.ToAttestation(consensus.State{}, sk)}},
-			},
-		},
 	}
 	ForEachHostAnnouncement(b, func(a HostAnnouncement) {
 		if a.PublicKey != sk.PublicKey() {
@@ -31,3 +29,53 @@ func TestForEachHostAnnouncement(t *testing.T) {
 		}
 	})
 }
+
+func TestForEachV2HostAnnouncement(t *testing.T) {
+	sk := types.GeneratePrivateKey()
+	ha := V2HostAnnouncement([]NetAddress{
+		{Protocol: "tcp", Address: "foo.bar:1234"},
+		{Protocol: "tcp6", Address: "baz.qux:5678"},
+		{Protocol: "webtransport", Address: "quux.corge:91011"},
+	})
+	randomAttestation := types.Attestation{
+		PublicKey: sk.PublicKey(),
+		Key:       "foo",
+		Value:     frand.Bytes(60),
+	}
+	cs := consensus.State{}
+	randomAttestation.Signature = sk.SignHash(cs.AttestationSigHash(randomAttestation))
+
+	invalidData := make([]byte, 100)
+	binary.LittleEndian.PutUint64(invalidData, math.MaxUint64)
+	extraBigAttestation := types.Attestation{
+		PublicKey: sk.PublicKey(),
+		Key:       attestationHostAnnouncement,
+		Value:     invalidData,
+	}
+	extraBigAttestation.Signature = sk.SignHash(cs.AttestationSigHash(extraBigAttestation))
+
+	b := types.Block{
+		V2: &types.V2BlockData{
+			Transactions: []types.V2Transaction{
+				{Attestations: []types.Attestation{
+					randomAttestation,
+					extraBigAttestation,
+					ha.ToAttestation(consensus.State{}, sk),
+				}},
+			},
+		},
+	}
+	ForEachV2HostAnnouncement(b, func(pk types.PublicKey, addresses []NetAddress) {
+		if pk != sk.PublicKey() {
+			t.Error("pubkey mismatch")
+		} else if len(addresses) != len(ha) {
+			t.Error("length mismatch")
+		} else {
+			for i := range addresses {
+				if addresses[i] != ha[i] {
+					t.Error("address mismatch:", addresses[i], ha[i])
+				}
+			}
+		}
+	})
+}