Merge pull request #305 from boschresearch/302-wire-msg-types-rename

Rename wire message types

Author: matthiasgeihs

client/channel.go

@@ -209,7 +209,7 @@ func (c *Channel) initExchangeSigsAndEnable(ctx context.Context) error {
 
 	send := make(chan error)
 	go func() {
-		send <- c.conn.Send(ctx, &msgChannelUpdateAcc{
+		send <- c.conn.Send(ctx, &ChannelUpdateAccMsg{
 			ChannelID: c.ID(),
 			Version:   0,
 			Sig:       sig,
@@ -220,7 +220,7 @@ func (c *Channel) initExchangeSigsAndEnable(ctx context.Context) error {
 	if err != nil {
 		return errors.WithMessage(err, "receiving initial state sig")
 	}
-	acc, ok := cm.(*msgChannelUpdateAcc)
+	acc, ok := cm.(*ChannelUpdateAccMsg)
 	if !ok {
 		return errors.Errorf(
 			"received unexpected message of type (%T) from peer[%d]: %v",

client/client.go

@@ -171,19 +171,19 @@ func (c *Client) Handle(ph ProposalHandler, uh UpdateHandler) {
 		msg := env.Msg
 
 		switch msg := msg.(type) {
-		case *LedgerChannelProposal:
+		case *LedgerChannelProposalMsg:
 			go c.handleChannelProposal(ph, env.Sender, msg)
-		case *SubChannelProposal:
+		case *SubChannelProposalMsg:
 			go c.handleChannelProposal(ph, env.Sender, msg)
-		case *VirtualChannelProposal:
+		case *VirtualChannelProposalMsg:
 			go c.handleChannelProposal(ph, env.Sender, msg)
-		case *msgChannelUpdate:
+		case *ChannelUpdateMsg:
 			go c.handleChannelUpdate(uh, env.Sender, msg)
-		case *virtualChannelFundingProposal:
+		case *VirtualChannelFundingProposalMsg:
 			go c.handleChannelUpdate(uh, env.Sender, msg)
-		case *virtualChannelSettlementProposal:
+		case *VirtualChannelSettlementProposalMsg:
 			go c.handleChannelUpdate(uh, env.Sender, msg)
-		case *msgChannelSync:
+		case *ChannelSyncMsg:
 			go c.handleSyncMsg(env.Sender, msg)
 		default:
 			c.log.Error("Unexpected %T message received in request loop")

client/proposal.go

@@ -279,7 +279,7 @@ func (c *Client) handleChannelProposalRej(
 	ctx context.Context, p wire.Address,
 	req ChannelProposal, reason string,
 ) error {
-	msgReject := &ChannelProposalRej{
+	msgReject := &ChannelProposalRejMsg{
 		ProposalID: req.ProposalID(),
 		Reason:     reason,
 	}
@@ -310,7 +310,7 @@ func (c *Client) proposeTwoPartyChannel(
 		acc, isAcc := e.Msg.(ChannelProposalAccept)
 		return (isAcc && acc.Base().ProposalID == proposalID) ||
 			(e.Msg.Type() == wire.ChannelProposalRej &&
-				e.Msg.(*ChannelProposalRej).ProposalID == proposalID)
+				e.Msg.(*ChannelProposalRejMsg).ProposalID == proposalID)
 	}
 	receiver := wire.NewReceiver()
 	defer receiver.Close()
@@ -330,7 +330,7 @@ func (c *Client) proposeTwoPartyChannel(
 		}
 		return nil, errors.WithMessage(err, "receiving proposal response")
 	}
-	if rej, ok := env.Msg.(*ChannelProposalRej); ok {
+	if rej, ok := env.Msg.(*ChannelProposalRejMsg); ok {
 		return nil, newPeerRejectedError("channel proposal", rej.Reason)
 	}
 
@@ -384,11 +384,11 @@ func (c *Client) validTwoPartyProposal(
 	}
 
 	switch prop := proposal.(type) {
-	case *SubChannelProposal:
+	case *SubChannelProposalMsg:
 		if err := c.validSubChannelProposal(prop); err != nil {
 			return errors.WithMessage(err, "validate subchannel proposal")
 		}
-	case *VirtualChannelProposal:
+	case *VirtualChannelProposalMsg:
 		if err := c.validVirtualChannelProposal(prop, ourIdx); err != nil {
 			return errors.WithMessage(err, "validate subchannel proposal")
 		}
@@ -397,7 +397,7 @@ func (c *Client) validTwoPartyProposal(
 	return nil
 }
 
-func (c *Client) validSubChannelProposal(proposal *SubChannelProposal) error {
+func (c *Client) validSubChannelProposal(proposal *SubChannelProposalMsg) error {
 	parent, ok := c.channels.Channel(proposal.Parent)
 	if !ok {
 		return errors.New("parent channel does not exist")
@@ -417,7 +417,7 @@ func (c *Client) validSubChannelProposal(proposal *SubChannelProposal) error {
 	return nil
 }
 
-func (c *Client) validVirtualChannelProposal(prop *VirtualChannelProposal, ourIdx channel.Index) error {
+func (c *Client) validVirtualChannelProposal(prop *VirtualChannelProposalMsg, ourIdx channel.Index) error {
 	numParents := len(prop.Parents)
 	numPeers := prop.NumPeers()
 	if numParents != numPeers {
@@ -569,9 +569,9 @@ func (c *Client) completeCPP(
 
 func (c *Client) proposalParent(prop ChannelProposal, partIdx channel.Index) (parentChannelID *channel.ID, parent *Channel, err error) {
 	switch prop := prop.(type) {
-	case *SubChannelProposal:
+	case *SubChannelProposalMsg:
 		parentChannelID = &prop.Parent
-	case *VirtualChannelProposal:
+	case *VirtualChannelProposalMsg:
 		parentChannelID = &prop.Parents[partIdx]
 	}
 
@@ -591,20 +591,20 @@ func (c *Client) mpcppParts(
 	acc ChannelProposalAccept,
 ) (parts []wallet.Address) {
 	switch p := prop.(type) {
-	case *LedgerChannelProposal:
+	case *LedgerChannelProposalMsg:
 		parts = participants(
 			p.Participant,
-			acc.(*LedgerChannelProposalAcc).Participant)
-	case *SubChannelProposal:
+			acc.(*LedgerChannelProposalAccMsg).Participant)
+	case *SubChannelProposalMsg:
 		ch, ok := c.channels.Channel(p.Parent)
 		if !ok {
 			c.log.Panic("unknown parent channel ID")
 		}
 		parts = ch.Params().Parts
-	case *VirtualChannelProposal:
+	case *VirtualChannelProposalMsg:
 		parts = participants(
 			p.Proposer,
-			acc.(*VirtualChannelProposalAcc).Responder,
+			acc.(*VirtualChannelProposalAccMsg).Responder,
 		)
 	default:
 		c.log.Panicf("unhandled %T", p)
@@ -614,13 +614,13 @@ func (c *Client) mpcppParts(
 
 func (c *Client) fundChannel(ctx context.Context, ch *Channel, prop ChannelProposal) error {
 	switch prop := prop.(type) {
-	case *LedgerChannelProposal:
+	case *LedgerChannelProposalMsg:
 		err := c.fundLedgerChannel(ctx, ch, prop.Base().FundingAgreement)
 		return errors.WithMessage(err, "funding ledger channel")
-	case *SubChannelProposal:
+	case *SubChannelProposalMsg:
 		err := c.fundSubchannel(ctx, prop, ch)
 		return errors.WithMessage(err, "funding subchannel")
-	case *VirtualChannelProposal:
+	case *VirtualChannelProposalMsg:
 		err := c.fundVirtualChannel(ctx, ch, prop)
 		return errors.WithMessage(err, "funding virtual channel")
 	}
@@ -657,7 +657,7 @@ func (c *Client) fundLedgerChannel(ctx context.Context, ch *Channel, agreement c
 	return c.completeFunding(ctx, ch)
 }
 
-func (c *Client) fundSubchannel(ctx context.Context, prop *SubChannelProposal, subChannel *Channel) (err error) {
+func (c *Client) fundSubchannel(ctx context.Context, prop *SubChannelProposalMsg, subChannel *Channel) (err error) {
 	parentChannel, ok := c.channels.Channel(prop.Parent)
 	if !ok {
 		return errors.New("referenced parent channel not found")
@@ -684,7 +684,7 @@ func (c *Client) fundSubchannel(ctx context.Context, prop *SubChannelProposal, s
 func enableVer0Cache(c wire.Cacher) *wire.Predicate {
 	p := func(m *wire.Envelope) bool {
 		return m.Msg.Type() == wire.ChannelUpdateAcc &&
-			m.Msg.(*msgChannelUpdateAcc).Version == 0
+			m.Msg.(*ChannelUpdateAccMsg).Version == 0
 	}
 	c.Cache(&p)
 	return &p

client/proposal_internal_test.go

@@ -45,12 +45,12 @@ func TestClient_validTwoPartyProposal(t *testing.T) {
 	require.Len(t, validProp.Peers, 2)
 
 	validProp3Peers := NewRandomLedgerChannelProposal(rng, channeltest.WithNumParts(3))
-	invalidProp := &LedgerChannelProposal{}
+	invalidProp := &LedgerChannelProposalMsg{}
 	*invalidProp = *validProp                // shallow copy
 	invalidProp.Base().ChallengeDuration = 0 // invalidate
 
 	tests := []struct {
-		prop     *LedgerChannelProposal
+		prop     *LedgerChannelProposalMsg
 		ourIdx   channel.Index
 		peerAddr wallet.Address
 		valid    bool
@@ -104,7 +104,7 @@ func TestChannelProposal_assertValidNumParts(t *testing.T) {
 
 func TestProposalResponder_Accept_Nil(t *testing.T) {
 	p := new(ProposalResponder)
-	_, err := p.Accept(nil, new(LedgerChannelProposalAcc)) //nolint:staticcheck
+	_, err := p.Accept(nil, new(LedgerChannelProposalAccMsg)) //nolint:staticcheck
 	assert.Error(t, err, "context")
 }
 
@@ -149,11 +149,11 @@ func NewRandomBaseChannelProposal(rng *rand.Rand, opts ...channeltest.RandomOpt)
 	return prop
 }
 
-func NewRandomLedgerChannelProposal(rng *rand.Rand, opts ...channeltest.RandomOpt) *LedgerChannelProposal {
+func NewRandomLedgerChannelProposal(rng *rand.Rand, opts ...channeltest.RandomOpt) *LedgerChannelProposalMsg {
 	opt := make(channeltest.RandomOpt).Append(opts...)
 	base := NewRandomBaseChannelProposal(rng, opt)
 	peers := wiretest.NewRandomAddresses(rng, base.NumPeers())
-	return &LedgerChannelProposal{
+	return &LedgerChannelProposalMsg{
 		BaseChannelProposal: base,
 		Participant:         wallettest.NewRandomAddress(rng),
 		Peers:               peers,