lnd/amp/derivation_test.go

package amp_test

import (
	"testing"

	"github.com/lightningnetwork/lnd/amp"
	"github.com/stretchr/testify/require"
)

type sharerTest struct {
	name      string
	numShares int
}

var sharerTests = []sharerTest{
	{
		name:      "root only",
		numShares: 1,
	},
	{
		name:      "two shares",
		numShares: 2,
	},
	{
		name:      "many shares",
		numShares: 10,
	},
}

// TestSharer executes the end-to-end derivation between sender and receiver,
// asserting that shares are properly computed and, when reconstructed by the
// receiver, produce identical child hashes and preimages as the sender.
func TestSharer(t *testing.T) {
	for _, test := range sharerTests {
		test := test
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()

			testSharer(t, test)
		})
	}
}

func testSharer(t *testing.T, test sharerTest) {
	// Construct a new sharer with a random seed.
	var (
		sharer amp.Sharer
		err    error
	)
	sharer, err = amp.NewSeedSharer()
	require.NoError(t, err)

	// Assert that we can instantiate an equivalent root sharer using the
	// root share.
	root := sharer.Root()
	sharerFromRoot := amp.SeedSharerFromRoot(&root)
	require.Equal(t, sharer, sharerFromRoot)

	// Generate numShares-1 randomized shares.
	children := make([]*amp.Child, 0, test.numShares)
	for i := 0; i < test.numShares-1; i++ {
		var left amp.Sharer
		left, sharer, err = sharer.Split()
		require.NoError(t, err)

		child := left.Child(0)

		assertChildShare(t, child, 0)
		children = append(children, child)
	}

	// Compute the final share and finalize the sharing.
	child := sharer.Child(0)

	assertChildShare(t, child, 0)
	children = append(children, child)

	assertReconstruction(t, children...)
}

// assertChildShare checks that the child has the expected child index, and that
// the child's preimage is valid for the its hash.
func assertChildShare(t *testing.T, child *amp.Child, expIndex int) {
	t.Helper()

	require.Equal(t, uint32(expIndex), child.Index)
	require.True(t, child.Preimage.Matches(child.Hash))
}

// assertReconstruction takes a list of children and simulates the receiver
// recombining the shares, and then deriving the child preimage and hash for
// each HTLC. This asserts that the receiver can always rederive the full set of
// children knowing only the shares and child indexes for each.
func assertReconstruction(t *testing.T, children ...*amp.Child) {
	t.Helper()

	// Reconstruct a child descriptor for each of the provided children.
	// In practice, the receiver will only know the share and the child
	// index it learns for each HTLC.
	descs := make([]amp.ChildDesc, 0, len(children))
	for _, child := range children {
		descs = append(descs, amp.ChildDesc{
			Share: child.Share,
			Index: child.Index,
		})
	}

	// Now, recombine the shares and rederive a child for each of the
	// descriptors above. The resulting set of children should exactly match
	// the set provided.
	children2 := amp.ReconstructChildren(descs...)
	require.Equal(t, children, children2)
}