threshold/protocols/lss/reshare/reshare_test.go

package reshare_test

import (
	"testing"

	"github.com/luxfi/threshold/pkg/math/curve"
	"github.com/luxfi/threshold/pkg/party"
	"github.com/luxfi/threshold/pkg/pool"
	"github.com/luxfi/threshold/protocols/lss/config"
	"github.com/luxfi/threshold/protocols/lss/reshare"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestReshareStart(t *testing.T) {
	group := curve.Secp256k1{}

	// Create initial configuration
	oldParties := []party.ID{"alice", "bob", "charlie"}
	cfg := &config.Config{
		ID:         party.ID("alice"),
		Group:      group,
		Threshold:  2,
		Generation: 1,
		ECDSA:      group.NewScalar(),
		Public:     make(map[party.ID]*config.Public),
		ChainKey:   []byte("chain-key"),
		RID:        []byte("rid"),
	}

	// Add public shares
	for _, id := range oldParties {
		cfg.Public[id] = &config.Public{
			ECDSA: group.NewScalar().ActOnBase(),
		}
	}

	newParties := []party.ID{"alice", "bob", "charlie", "david", "eve"}
	newThreshold := 3
	pl := pool.NewPool(0)
	defer pl.TearDown()

	startFunc := reshare.Start(cfg, newParties, newThreshold, pl)
	assert.NotNil(t, startFunc)

	// Test that the start function creates a session
	sessionID := []byte("test-session")
	session, err := startFunc(sessionID)
	if err != nil {
		require.NoError(t, err)
		return
	}
	require.NoError(t, err)
	assert.NotNil(t, session)
}

func TestReshareParameterValidation(t *testing.T) {
	group := curve.Secp256k1{}
	pl := pool.NewPool(0)
	defer pl.TearDown()

	baseCfg := &config.Config{
		ID:         party.ID("alice"),
		Group:      group,
		Threshold:  2,
		Generation: 1,
		ECDSA:      group.NewScalar(),
		Public: map[party.ID]*config.Public{
			"alice":   {ECDSA: group.NewScalar().ActOnBase()},
			"bob":     {ECDSA: group.NewScalar().ActOnBase()},
			"charlie": {ECDSA: group.NewScalar().ActOnBase()},
		},
	}

	testCases := []struct {
		name         string
		newParties   []party.ID
		newThreshold int
		expectError  bool
	}{
		{
			name:         "add parties",
			newParties:   []party.ID{"alice", "bob", "charlie", "david", "eve"},
			newThreshold: 3,
			expectError:  false,
		},
		{
			name:         "remove parties",
			newParties:   []party.ID{"alice", "bob"},
			newThreshold: 1,
			expectError:  false,
		},
		{
			name:         "change threshold only",
			newParties:   []party.ID{"alice", "bob", "charlie"},
			newThreshold: 3,
			expectError:  true, // threshold must be < n
		},
		{
			name:         "invalid threshold too high",
			newParties:   []party.ID{"alice", "bob"},
			newThreshold: 3,
			expectError:  true,
		},
		{
			name:         "invalid threshold zero",
			newParties:   []party.ID{"alice", "bob", "charlie"},
			newThreshold: 0,
			expectError:  true,
		},
		{
			name:         "empty party list",
			newParties:   []party.ID{},
			newThreshold: 1,
			expectError:  true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			startFunc := reshare.Start(baseCfg, tc.newParties, tc.newThreshold, pl)
			assert.NotNil(t, startFunc)

			// Validation happens when creating the session
			session, err := startFunc([]byte("session"))
			if tc.expectError {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
				assert.NotNil(t, session)
			}
		})
	}
}

func TestReshareGenerationIncrement(t *testing.T) {
	group := curve.Secp256k1{}

	// Test that resharing increments generation number
	generations := []uint64{0, 1, 5, 100}

	for _, gen := range generations {
		cfg := &config.Config{
			ID:         party.ID("alice"),
			Group:      group,
			Threshold:  2,
			Generation: gen,
			ECDSA:      group.NewScalar(),
			Public: map[party.ID]*config.Public{
				"alice":   {ECDSA: group.NewScalar().ActOnBase()},
				"bob":     {ECDSA: group.NewScalar().ActOnBase()},
				"charlie": {ECDSA: group.NewScalar().ActOnBase()},
			},
		}

		newParties := []party.ID{"alice", "bob", "charlie", "david"}
		pl := pool.NewPool(0)
		defer pl.TearDown()

		startFunc := reshare.Start(cfg, newParties, 3, pl)
		assert.NotNil(t, startFunc)

		// After successful reshare, generation should be incremented
		// This would be verified in the result, but protocol may not be fully implemented
		session, err := startFunc([]byte("session"))
		if err != nil {
			require.NoError(t, err)
			return
		}
		assert.NotNil(t, session)
	}
}

func TestReshareMaintainsPublicKey(t *testing.T) {
	// Test that public key is maintained after resharing

	// This test would verify that the public key remains the same
	// after resharing, which is a critical property of the LSS protocol
	// It requires the full protocol to be implemented to run
}

func TestConcurrentReshare(t *testing.T) {
	group := curve.Secp256k1{}
	pl := pool.NewPool(0)
	defer pl.TearDown()

	// Create multiple configs for different parties
	partyIDs := []party.ID{"alice", "bob", "charlie"}
	configs := make([]*config.Config, len(partyIDs))

	publicShares := make(map[party.ID]*config.Public)
	for _, id := range partyIDs {
		publicShares[id] = &config.Public{
			ECDSA: group.NewScalar().ActOnBase(),
		}
	}

	for i, id := range partyIDs {
		configs[i] = &config.Config{
			ID:         id,
			Group:      group,
			Threshold:  2,
			Generation: 1,
			ECDSA:      group.NewScalar(),
			Public:     publicShares,
		}
	}

	newParties := []party.ID{"alice", "bob", "charlie", "david"}
	newThreshold := 3

	// Start reshare for each party concurrently
	done := make(chan bool, len(configs))

	for _, cfg := range configs {
		go func(c *config.Config) {
			startFunc := reshare.Start(c, newParties, newThreshold, pl)
			if startFunc != nil {
				_, err := startFunc([]byte("session"))
				done <- err == nil
			} else {
				done <- false
			}
		}(cfg)
	}

	// Wait for all parties
	successCount := 0
	for range configs {
		if <-done {
			successCount++
		}
	}

	// At least one should succeed
	assert.Greater(t, successCount, 0, "At least one concurrent reshare should succeed")
}