🔀 Merge pull request #114 from perun-network/prepare-82-virtual-channels

ggwpez · web-flow · commit c50c75f8aaf0 · 2021-06-22T10:21:04.000+02:00
Prepare 82 virtual channels
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -34,7 +34,7 @@ jobs:
       - name: Lint
         uses: golangci/golangci-lint-action@v2
         with:
-          version: v1.29
+          version: v1.40.1
 
   tests:
     name: Tests
diff --git a/backend/ethereum/channel/backend.go b/backend/ethereum/channel/backend.go
@@ -229,7 +229,7 @@ func pwToCommonAddresses(addr []wallet.Address) []common.Address {
 func FromEthState(app channel.App, s *adjudicator.ChannelState) channel.State {
 	locked := make([]channel.SubAlloc, len(s.Outcome.Locked))
 	for i, sub := range s.Outcome.Locked {
-		locked[i] = channel.SubAlloc{ID: sub.ID, Bals: sub.Balances}
+		locked[i] = *channel.NewSubAlloc(sub.ID, sub.Balances)
 	}
 	alloc := channel.Allocation{
 		Assets:   fromEthAssets(s.Outcome.Assets),
diff --git a/backend/ethereum/channel/register_test.go b/backend/ethereum/channel/register_test.go
@@ -30,7 +30,6 @@ import (
 	pkgtest "perun.network/go-perun/pkg/test"
 )
 
-// nolint: dupl
 func TestAdjudicator_MultipleRegisters(t *testing.T) {
 	t.Run("Register 1 party parallel", func(t *testing.T) { registerMultipleConcurrent(t, 1, true) })
 	t.Run("Register 2 party parallel", func(t *testing.T) { registerMultipleConcurrent(t, 2, true) })
diff --git a/backend/ethereum/channel/withdraw_test.go b/backend/ethereum/channel/withdraw_test.go
@@ -16,6 +16,7 @@ package channel_test
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"testing"
 	"time"
@@ -31,15 +32,18 @@ import (
 	pkgtest "perun.network/go-perun/pkg/test"
 )
 
-// nolint: dupl
 func TestAdjudicator_MultipleWithdraws_FinalState(t *testing.T) {
-	t.Run("Withdraw 1 party parallel", func(t *testing.T) { withdrawMultipleConcurrentFinal(t, 1, true) })
-	t.Run("Withdraw 2 party parallel", func(t *testing.T) { withdrawMultipleConcurrentFinal(t, 2, true) })
-	t.Run("Withdraw 5 party parallel", func(t *testing.T) { withdrawMultipleConcurrentFinal(t, 5, true) })
-	t.Run("Withdraw 10 party parallel", func(t *testing.T) { withdrawMultipleConcurrentFinal(t, 10, true) })
-	t.Run("Withdraw 1 party sequential", func(t *testing.T) { withdrawMultipleConcurrentFinal(t, 1, false) })
-	t.Run("Withdraw 2 party sequential", func(t *testing.T) { withdrawMultipleConcurrentFinal(t, 2, false) })
-	t.Run("Withdraw 5 party sequential", func(t *testing.T) { withdrawMultipleConcurrentFinal(t, 5, false) })
+	testParallel := func(n int) {
+		t.Run(fmt.Sprintf("Withdraw %d party parallel", n), func(t *testing.T) { withdrawMultipleConcurrentFinal(t, n, true) })
+	}
+	testSequential := func(n int) {
+		t.Run(fmt.Sprintf("Withdraw %d party sequential", n), func(t *testing.T) { withdrawMultipleConcurrentFinal(t, n, false) })
+	}
+
+	for _, n := range []int{1, 2, 5} {
+		testParallel(n)
+		testSequential(n)
+	}
 }
 
 func withdrawMultipleConcurrentFinal(t *testing.T, numParts int, parallel bool) {
diff --git a/channel/allocation_test.go b/channel/allocation_test.go
@@ -282,9 +282,14 @@ func TestAllocationValidLimits(t *testing.T) {
 		}
 
 		for i := range allocation.Locked {
-			allocation.Locked[i] = channel.SubAlloc{
-				ID:   channel.ID{byte(i), byte(i >> 8), byte(i >> 16), byte(i >> 24)},
-				Bals: make([]channel.Bal, x.numAssets)}
+			allocation.Locked[i] = *channel.NewSubAlloc(
+				channel.ID{byte(i), byte(i >> 8), byte(i >> 16), byte(i >> 24)},
+				make([]channel.Bal, x.numAssets),
+			)
+			allocation.Locked[i] = *channel.NewSubAlloc(
+				channel.ID{byte(i), byte(i >> 8), byte(i >> 16), byte(i >> 24)},
+				make([]channel.Bal, x.numAssets),
+			)
 
 			for j := range allocation.Locked[i].Bals {
 				bal := big.NewInt(int64(x.numAssets)*int64(i) + int64(j) + 1)
@@ -372,7 +377,7 @@ func TestAllocation_Sum(t *testing.T) {
 
 		{
 			"single asset/one participants/one locked",
-			*test.NewRandomAllocation(rng, test.WithNumAssets(1), test.WithNumParts(1), test.WithLocked(channel.SubAlloc{Bals: []channel.Bal{big.NewInt(2)}}), test.WithBalancesInRange(big.NewInt(1), big.NewInt(1))),
+			*test.NewRandomAllocation(rng, test.WithNumAssets(1), test.WithNumParts(1), test.WithLocked(*channel.NewSubAlloc(channel.ID{}, []channel.Bal{big.NewInt(2)})), test.WithBalancesInRange(big.NewInt(1), big.NewInt(1))),
 			[]channel.Bal{big.NewInt(3)},
 		},
 
@@ -485,7 +490,7 @@ func TestAllocation_Valid(t *testing.T) {
 					{big.NewInt(64), big.NewInt(128)},
 				},
 				Locked: []channel.SubAlloc{
-					{channel.Zero, []channel.Bal{big.NewInt(4)}},
+					*channel.NewSubAlloc(channel.Zero, []channel.Bal{big.NewInt(4)}),
 				},
 			},
 			false,
@@ -501,7 +506,7 @@ func TestAllocation_Valid(t *testing.T) {
 					{big.NewInt(64), big.NewInt(128)},
 				},
 				Locked: []channel.SubAlloc{
-					{channel.Zero, []channel.Bal{big.NewInt(-1)}},
+					*channel.NewSubAlloc(channel.Zero, []channel.Bal{big.NewInt(-1)}),
 				},
 			},
 			false,
@@ -529,7 +534,7 @@ func TestAllocation_Valid(t *testing.T) {
 					{big.NewInt(2), big.NewInt(16)},
 				},
 				Locked: []channel.SubAlloc{
-					{channel.Zero, []channel.Bal{big.NewInt(4), big.NewInt(-1)}},
+					*channel.NewSubAlloc(channel.Zero, []channel.Bal{big.NewInt(4), big.NewInt(-1)}),
 				},
 			},
 			false,
@@ -549,9 +554,9 @@ func TestAllocation_Valid(t *testing.T) {
 // suballocation serialization.
 func TestSuballocSerialization(t *testing.T) {
 	ss := []perunio.Serializer{
-		&channel.SubAlloc{channel.ID{2}, []channel.Bal{}},
-		&channel.SubAlloc{channel.ID{3}, []channel.Bal{big.NewInt(0)}},
-		&channel.SubAlloc{channel.ID{4}, []channel.Bal{big.NewInt(5), big.NewInt(1 << 62)}},
+		channel.NewSubAlloc(channel.ID{2}, []channel.Bal{}),
+		channel.NewSubAlloc(channel.ID{3}, []channel.Bal{big.NewInt(0)}),
+		channel.NewSubAlloc(channel.ID{4}, []channel.Bal{big.NewInt(5), big.NewInt(1 << 62)}),
 	}
 
 	iotest.GenericSerializerTest(t, ss...)
diff --git a/channel/machine.go b/channel/machine.go
@@ -68,7 +68,8 @@ const (
 	Progressed
 	Withdrawing
 	Withdrawn
-	LastPhase = Withdrawn
+	// LastPhase contains the value of the last phase. This is useful for testing.
+	LastPhase = int(Withdrawn)
 )
 
 func (p Phase) String() string {
diff --git a/channel/persistence/keyvalue/cache.go b/channel/persistence/keyvalue/cache.go
@@ -38,6 +38,7 @@ type channelCache struct {
 	peerChannels map[string]map[channel.ID]struct{} // Address -> Set<chID>
 }
 
+// nolint: unused
 func (c *channelCache) addPeerChannel(addr wire.Address, chID channel.ID) {
 	c.mutex.Lock()
 	defer c.mutex.Unlock()
@@ -53,6 +54,7 @@ func (c *channelCache) addPeerChannel(addr wire.Address, chID channel.ID) {
 	}
 }
 
+// nolint: unused
 func (c *channelCache) deleteChannel(id channel.ID) []wire.Address {
 	c.mutex.Lock()
 	defer c.mutex.Unlock()
@@ -71,6 +73,7 @@ func (c *channelCache) deleteChannel(id channel.ID) []wire.Address {
 	return peers
 }
 
+// nolint: unused
 func (c *channelCache) clear() {
 	c.mutex.Lock()
 	defer c.mutex.Unlock()
diff --git a/channel/persistence/test/persistrestorertest.go b/channel/persistence/test/persistrestorertest.go
@@ -119,7 +119,7 @@ func GenericPersistRestorerTest(
 				chIndex := iterIdx
 				log.Error(subSeed)
 				seed := pkgtest.Seed("", subSeed, numChans, numPeers, chIndex, ch.ID())
-				rng := rand.New(rand.NewSource(seed))
+				rng := rand.New(rand.NewSource(seed)) // nolint: gosec
 
 				ch.Init(t, rng)
 				ch.SignAll(t)
diff --git a/channel/test/randomizer.go b/channel/test/randomizer.go
@@ -45,7 +45,7 @@ func SetRandomizer(r Randomizer) {
 
 // NewRandomPhase generates a random channel machine phase.
 func NewRandomPhase(rng *rand.Rand) channel.Phase {
-	return channel.Phase(rng.Intn(int(channel.LastPhase) + 1))
+	return channel.Phase(rng.Intn(channel.LastPhase + 1))
 }
 
 // NewRandomAsset generates a new random `channel.Asset`.
@@ -134,7 +134,7 @@ func NewRandomSubAlloc(rng *rand.Rand, opts ...RandomOpt) *channel.SubAlloc {
 		bals = NewRandomBals(rng, opt.NumAssets(rng), opt)
 	}
 
-	return &channel.SubAlloc{ID: id, Bals: bals}
+	return channel.NewSubAlloc(id, bals)
 }
 
 // NewRandomParamsAndState generates a new random `channel.Params` and `channel.State`.
diff --git a/client/adjudicate.go b/client/adjudicate.go
diff --git a/client/proposal.go b/client/proposal.go
@@ -304,8 +304,7 @@ func (c *Client) validTwoPartyProposal(
 	ourIdx int,
 	peerAddr wallet.Address,
 ) error {
-	base := proposal.Base()
-	if err := base.Valid(); err != nil {
+	if err := proposal.Valid(); err != nil {
 		return err
 	}
 
@@ -371,15 +370,6 @@ func (c *Client) validChannelProposalAcc(
 		return errors.Errorf("mismatched proposal ID %b and accept ID %b", propID, accID)
 	}
 
-	if proposal.Type() == wire.SubChannelProposal {
-		subProp := proposal.(*SubChannelProposal)
-
-		_, ok := c.channels.Get(subProp.Parent)
-		if !ok {
-			return errors.New("parent channel does not exist")
-		}
-	}
-
 	return nil
 }
 
@@ -602,7 +592,7 @@ type version1Cache struct {
 type cachedUpdate struct {
 	uh UpdateHandler
 	p  wire.Address
-	m  *msgChannelUpdate
+	m  ChannelUpdateProposal
 }
 
 // Error implements the error interface.
diff --git a/client/subchannel.go b/client/subchannel.go
@@ -111,7 +111,7 @@ func (c *Channel) withdrawSubChannel(ctx context.Context, sub *Channel) error {
 
 func (c *Channel) registerSubChannelFunding(id channel.ID, alloc []channel.Bal) {
 	filter := func(cu ChannelUpdate) bool {
-		expected := channel.SubAlloc{ID: id, Bals: alloc}
+		expected := *channel.NewSubAlloc(id, alloc)
 		_, containedBefore := c.machine.State().SubAlloc(expected.ID)
 		subAlloc, containedAfter := cu.State.SubAlloc(expected.ID)
 		return !containedBefore && containedAfter && expected.Equal(&subAlloc) == nil
diff --git a/client/test/carol.go b/client/test/carol.go
@@ -57,8 +57,8 @@ func (r *Carol) exec(_cfg ExecConfig, ch *paymentChannel, propHandler *acceptNex
 	// start watcher
 	go func() {
 		r.log.Info("Starting channel watcher.")
-		assert.NoError(ch.Watch(r))
-		r.log.Debug("Channel watcher returned.")
+		err := ch.Watch(r)
+		r.log.Infof("Channel watcher returned: %v", err)
 	}()
 
 	// 1st stage - channel controller set up
diff --git a/client/test/progression.go b/client/test/progression.go
@@ -21,6 +21,7 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"perun.network/go-perun/channel"
+	"perun.network/go-perun/log"
 )
 
 // ProgressionExecConfig contains config parameters for the progression test.
@@ -30,22 +31,22 @@ type ProgressionExecConfig struct {
 
 // Watcher is a client that handles adjudicator events.
 type Watcher struct {
-	t          *testing.T
+	log.Logger
 	registered chan *channel.RegisteredEvent
 	progressed chan *channel.ProgressedEvent
 }
 
-func makeWatcher(t *testing.T) Watcher {
+func makeWatcher(log log.Logger) Watcher {
 	return Watcher{
-		t:          t,
+		Logger:     log,
 		registered: make(chan *channel.RegisteredEvent),
 		progressed: make(chan *channel.ProgressedEvent),
 	}
 }
 
 // HandleAdjudicatorEvent is the callback for adjudicator event handling.
 func (w *Watcher) HandleAdjudicatorEvent(e channel.AdjudicatorEvent) {
-	w.t.Logf("HandleAdjudicatorEvent: %v", e)
+	w.Infof("HandleAdjudicatorEvent: %v", e)
 	switch e := e.(type) {
 	case *channel.RegisteredEvent:
 		w.registered <- e
@@ -64,9 +65,10 @@ type Paul struct {
 
 // NewPaul creates a new party that executes the Paul protocol.
 func NewPaul(t *testing.T, setup RoleSetup) *Paul {
+	p := NewProposer(setup, t, 1)
 	return &Paul{
-		Proposer: *NewProposer(setup, t, 1),
-		Watcher:  makeWatcher(t),
+		Proposer: *p,
+		Watcher:  makeWatcher(p.log),
 	}
 }
 
@@ -83,8 +85,8 @@ func (r *Paul) exec(_cfg ExecConfig, ch *paymentChannel) {
 	// start watcher
 	go func() {
 		r.log.Info("Starting channel watcher.")
-		assert.NoError(ch.Watch(r))
-		r.log.Debug("Channel watcher returned.")
+		err := ch.Watch(r)
+		r.log.Infof("Channel watcher returned: %v", err)
 	}()
 
 	r.waitStage() // wait for setup complete
@@ -130,9 +132,10 @@ type Paula struct {
 
 // NewPaula creates a new party that executes the Paula protocol.
 func NewPaula(t *testing.T, setup RoleSetup) *Paula {
+	r := NewResponder(setup, t, 1)
 	return &Paula{
-		Responder: *NewResponder(setup, t, 1),
-		Watcher:   makeWatcher(t),
+		Responder: *r,
+		Watcher:   makeWatcher(r.log),
 	}
 }
 
@@ -149,8 +152,8 @@ func (r *Paula) exec(_cfg ExecConfig, ch *paymentChannel, _ *acceptNextPropHandl
 	// start watcher
 	go func() {
 		r.log.Info("Starting channel watcher.")
-		assert.NoError(ch.Watch(r))
-		r.log.Debug("Channel watcher returned.")
+		err := ch.Watch(r)
+		r.log.Infof("Channel watcher returned: %v", err)
 	}()
 
 	r.waitStage() // wait for setup complete
diff --git a/client/update.go b/client/update.go
diff --git a/client/updatemsgs.go b/client/updatemsgs.go
diff --git a/pkg/test/prng.go b/pkg/test/prng.go

Original file line number	Diff line number	Diff line change
`@@ -229,7 +229,7 @@ func pwToCommonAddresses(addr []wallet.Address) []common.Address {`
`229`	`229`	`func FromEthState(app channel.App, s *adjudicator.ChannelState) channel.State {`
`230`	`230`	`locked := make([]channel.SubAlloc, len(s.Outcome.Locked))`
`231`	`231`	`for i, sub := range s.Outcome.Locked {`
`232`		`- locked[i] = channel.SubAlloc{ID: sub.ID, Bals: sub.Balances}`
	`232`	`+ locked[i] = *channel.NewSubAlloc(sub.ID, sub.Balances)`
`233`	`233`	`}`
`234`	`234`	`alloc := channel.Allocation{`
`235`	`235`	`Assets: fromEthAssets(s.Outcome.Assets),`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,6 @@ import (`
`30`	`30`	`pkgtest "perun.network/go-perun/pkg/test"`
`31`	`31`	`)`
`32`	`32`
`33`		`-// nolint: dupl`
`34`	`33`	`func TestAdjudicator_MultipleRegisters(t *testing.T) {`
`35`	`34`	`t.Run("Register 1 party parallel", func(t *testing.T) { registerMultipleConcurrent(t, 1, true) })`
`36`	`35`	`t.Run("Register 2 party parallel", func(t *testing.T) { registerMultipleConcurrent(t, 2, true) })`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,8 @@ const (`
`68`	`68`	`Progressed`
`69`	`69`	`Withdrawing`
`70`	`70`	`Withdrawn`
`71`		`- LastPhase = Withdrawn`
	`71`	`+ // LastPhase contains the value of the last phase. This is useful for testing.`
	`72`	`+ LastPhase = int(Withdrawn)`
`72`	`73`	`)`
`73`	`74`
`74`	`75`	`func (p Phase) String() string {`
Original file line number	Diff line number	Diff line change
`@@ -38,6 +38,7 @@ type channelCache struct {`
`38`	`38`	`peerChannels map[string]map[channel.ID]struct{} // Address -> Set<chID>`
`39`	`39`	`}`
`40`	`40`
	`41`	`+// nolint: unused`
`41`	`42`	`func (c *channelCache) addPeerChannel(addr wire.Address, chID channel.ID) {`
`42`	`43`	`c.mutex.Lock()`
`43`	`44`	`defer c.mutex.Unlock()`
`@@ -53,6 +54,7 @@ func (c *channelCache) addPeerChannel(addr wire.Address, chID channel.ID) {`
`53`	`54`	`}`
`54`	`55`	`}`
`55`	`56`
	`57`	`+// nolint: unused`
`56`	`58`	`func (c *channelCache) deleteChannel(id channel.ID) []wire.Address {`
`57`	`59`	`c.mutex.Lock()`
`58`	`60`	`defer c.mutex.Unlock()`
`@@ -71,6 +73,7 @@ func (c *channelCache) deleteChannel(id channel.ID) []wire.Address {`
`71`	`73`	`return peers`
`72`	`74`	`}`
`73`	`75`
	`76`	`+// nolint: unused`
`74`	`77`	`func (c *channelCache) clear() {`
`75`	`78`	`c.mutex.Lock()`
`76`	`79`	`defer c.mutex.Unlock()`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ func SetRandomizer(r Randomizer) {`
`45`	`45`
`46`	`46`	`// NewRandomPhase generates a random channel machine phase.`
`47`	`47`	`func NewRandomPhase(rng *rand.Rand) channel.Phase {`
`48`		`- return channel.Phase(rng.Intn(int(channel.LastPhase) + 1))`
	`48`	`+ return channel.Phase(rng.Intn(channel.LastPhase + 1))`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	// NewRandomAsset generates a new random `channel.Asset`.
`@@ -134,7 +134,7 @@ func NewRandomSubAlloc(rng rand.Rand, opts ...RandomOpt) channel.SubAlloc {`
`134`	`134`	`bals = NewRandomBals(rng, opt.NumAssets(rng), opt)`
`135`	`135`	`}`
`136`	`136`
`137`		`- return &channel.SubAlloc{ID: id, Bals: bals}`
	`137`	`+ return channel.NewSubAlloc(id, bals)`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	// NewRandomParamsAndState generates a new random `channel.Params` and `channel.State`.