loop/loopdb/store_test.go

package loopdb

import (
	"crypto/sha256"
	"io/ioutil"
	"os"
	"path/filepath"
	"reflect"
	"testing"
	"time"

	"github.com/btcsuite/btcd/chaincfg"
	"github.com/btcsuite/btcd/chaincfg/chainhash"
	"github.com/coreos/bbolt"
	"github.com/lightninglabs/loop/test"
	"github.com/lightningnetwork/lnd/lntypes"
	"github.com/lightningnetwork/lnd/routing/route"
	"github.com/stretchr/testify/require"
)

var (
	senderKey = [33]byte{
		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
	}

	receiverKey = [33]byte{
		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
	}

	testPreimage = lntypes.Preimage([32]byte{
		1, 1, 1, 1, 2, 2, 2, 2,
		3, 3, 3, 3, 4, 4, 4, 4,
		1, 1, 1, 1, 2, 2, 2, 2,
		3, 3, 3, 3, 4, 4, 4, 4,
	})

	testTime = time.Date(2018, time.January, 9, 14, 00, 00, 0, time.UTC)
)

// TestLoopOutStore tests all the basic functionality of the current bbolt
// swap store.
func TestLoopOutStore(t *testing.T) {
	destAddr := test.GetDestAddr(t, 0)
	initiationTime := time.Date(2018, 11, 1, 0, 0, 0, 0, time.UTC)

	// Next, we'll make a new pending swap that we'll insert into the
	// database shortly.
	unrestrictedSwap := LoopOutContract{
		SwapContract: SwapContract{
			AmountRequested: 100,
			Preimage:        testPreimage,
			CltvExpiry:      144,
			SenderKey:       senderKey,

			ReceiverKey: receiverKey,
			MaxMinerFee: 10,
			MaxSwapFee:  20,

			InitiationHeight: 99,

			// Convert to/from unix to remove timezone, so that it
			// doesn't interfere with DeepEqual.
			InitiationTime: time.Unix(0, initiationTime.UnixNano()),
		},
		MaxPrepayRoutingFee:     40,
		PrepayInvoice:           "prepayinvoice",
		DestAddr:                destAddr,
		SwapInvoice:             "swapinvoice",
		MaxSwapRoutingFee:       30,
		SweepConfTarget:         2,
		HtlcConfirmations:       2,
		SwapPublicationDeadline: time.Unix(0, initiationTime.UnixNano()),
	}

	t.Run("no outgoing set", func(t *testing.T) {
		testLoopOutStore(t, &unrestrictedSwap)
	})

	restrictedSwap := unrestrictedSwap
	restrictedSwap.OutgoingChanSet = ChannelSet{1, 2}

	t.Run("two channel outgoing set", func(t *testing.T) {
		testLoopOutStore(t, &restrictedSwap)
	})

	labelledSwap := unrestrictedSwap
	labelledSwap.Label = "test label"
	t.Run("labelled swap", func(t *testing.T) {
		testLoopOutStore(t, &labelledSwap)
	})

}

// testLoopOutStore tests the basic functionality of the current bbolt
// swap store for specific swap parameters.
func testLoopOutStore(t *testing.T, pendingSwap *LoopOutContract) {
	tempDirName, err := ioutil.TempDir("", "clientstore")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tempDirName)

	store, err := NewBoltSwapStore(tempDirName, &chaincfg.MainNetParams)
	if err != nil {
		t.Fatal(err)
	}

	// First, verify that an empty database has no active swaps.
	swaps, err := store.FetchLoopOutSwaps()
	if err != nil {
		t.Fatal(err)
	}
	if len(swaps) != 0 {
		t.Fatal("expected empty store")
	}

	// checkSwap is a test helper function that'll assert the state of a
	// swap.
	checkSwap := func(expectedState SwapState) {
		t.Helper()

		swaps, err := store.FetchLoopOutSwaps()
		if err != nil {
			t.Fatal(err)
		}

		if len(swaps) != 1 {
			t.Fatal("expected pending swap in store")
		}

		swap := swaps[0].Contract
		if !reflect.DeepEqual(swap, pendingSwap) {
			t.Fatal("invalid pending swap data")
		}

		if swaps[0].State().State != expectedState {
			t.Fatalf("expected state %v, but got %v",
				expectedState, swaps[0].State(),
			)
		}

		if expectedState == StatePreimageRevealed {
			require.NotNil(t, swaps[0].State().HtlcTxHash)
		}
	}

	hash := pendingSwap.Preimage.Hash()

	// If we create a new swap, then it should show up as being initialized
	// right after.
	if err := store.CreateLoopOut(hash, pendingSwap); err != nil {
		t.Fatal(err)
	}
	checkSwap(StateInitiated)

	// Trying to make the same swap again should result in an error.
	if err := store.CreateLoopOut(hash, pendingSwap); err == nil {
		t.Fatal("expected error on storing duplicate")
	}
	checkSwap(StateInitiated)

	// Next, we'll update to the next state of the pre-image being
	// revealed. The state should be reflected here again.
	err = store.UpdateLoopOut(
		hash, testTime,
		SwapStateData{
			State:      StatePreimageRevealed,
			HtlcTxHash: &chainhash.Hash{1, 6, 2},
		},
	)
	if err != nil {
		t.Fatal(err)
	}
	checkSwap(StatePreimageRevealed)

	// Next, we'll update to the final state to ensure that the state is
	// properly updated.
	err = store.UpdateLoopOut(
		hash, testTime,
		SwapStateData{
			State: StateFailInsufficientValue,
		},
	)
	if err != nil {
		t.Fatal(err)
	}
	checkSwap(StateFailInsufficientValue)

	if err := store.Close(); err != nil {
		t.Fatal(err)
	}

	// If we re-open the same store, then the state of the current swap
	// should be the same.
	store, err = NewBoltSwapStore(tempDirName, &chaincfg.MainNetParams)
	if err != nil {
		t.Fatal(err)
	}
	checkSwap(StateFailInsufficientValue)
}

// TestLoopInStore tests all the basic functionality of the current bbolt
// swap store.
func TestLoopInStore(t *testing.T) {
	initiationTime := time.Date(2018, 11, 1, 0, 0, 0, 0, time.UTC)

	// Next, we'll make a new pending swap that we'll insert into the
	// database shortly.
	lastHop := route.Vertex{1, 2, 3}

	pendingSwap := LoopInContract{
		SwapContract: SwapContract{
			AmountRequested:  100,
			Preimage:         testPreimage,
			CltvExpiry:       144,
			SenderKey:        senderKey,
			ReceiverKey:      receiverKey,
			MaxMinerFee:      10,
			MaxSwapFee:       20,
			InitiationHeight: 99,

			// Convert to/from unix to remove timezone, so that it
			// doesn't interfere with DeepEqual.
			InitiationTime: time.Unix(0, initiationTime.UnixNano()),
		},
		HtlcConfTarget: 2,
		LastHop:        &lastHop,
		ExternalHtlc:   true,
	}

	t.Run("loop in", func(t *testing.T) {
		testLoopInStore(t, pendingSwap)
	})

	labelledSwap := pendingSwap
	labelledSwap.Label = "test label"
	t.Run("loop in with label", func(t *testing.T) {
		testLoopInStore(t, labelledSwap)
	})
}

func testLoopInStore(t *testing.T, pendingSwap LoopInContract) {
	tempDirName, err := ioutil.TempDir("", "clientstore")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tempDirName)

	store, err := NewBoltSwapStore(tempDirName, &chaincfg.MainNetParams)
	if err != nil {
		t.Fatal(err)
	}

	// First, verify that an empty database has no active swaps.
	swaps, err := store.FetchLoopInSwaps()
	if err != nil {
		t.Fatal(err)
	}
	if len(swaps) != 0 {
		t.Fatal("expected empty store")
	}

	// checkSwap is a test helper function that'll assert the state of a
	// swap.
	checkSwap := func(expectedState SwapState) {
		t.Helper()

		swaps, err := store.FetchLoopInSwaps()
		if err != nil {
			t.Fatal(err)
		}

		if len(swaps) != 1 {
			t.Fatal("expected pending swap in store")
		}

		swap := swaps[0].Contract
		if !reflect.DeepEqual(swap, &pendingSwap) {
			t.Fatal("invalid pending swap data")
		}

		if swaps[0].State().State != expectedState {
			t.Fatalf("expected state %v, but got %v",
				expectedState, swaps[0].State(),
			)
		}
	}

	hash := sha256.Sum256(testPreimage[:])

	// If we create a new swap, then it should show up as being initialized
	// right after.
	if err := store.CreateLoopIn(hash, &pendingSwap); err != nil {
		t.Fatal(err)
	}
	checkSwap(StateInitiated)

	// Trying to make the same swap again should result in an error.
	if err := store.CreateLoopIn(hash, &pendingSwap); err == nil {
		t.Fatal("expected error on storing duplicate")
	}
	checkSwap(StateInitiated)

	// Next, we'll update to the next state of the pre-image being
	// revealed. The state should be reflected here again.
	err = store.UpdateLoopIn(
		hash, testTime,
		SwapStateData{
			State: StatePreimageRevealed,
		},
	)
	if err != nil {
		t.Fatal(err)
	}
	checkSwap(StatePreimageRevealed)

	// Next, we'll update to the final state to ensure that the state is
	// properly updated.
	err = store.UpdateLoopIn(
		hash, testTime,
		SwapStateData{
			State: StateFailInsufficientValue,
		},
	)
	if err != nil {
		t.Fatal(err)
	}
	checkSwap(StateFailInsufficientValue)

	if err := store.Close(); err != nil {
		t.Fatal(err)
	}

	// If we re-open the same store, then the state of the current swap
	// should be the same.
	store, err = NewBoltSwapStore(tempDirName, &chaincfg.MainNetParams)
	if err != nil {
		t.Fatal(err)
	}
	checkSwap(StateFailInsufficientValue)
}

// TestVersionNew tests that a new database is initialized with the current
// version.
func TestVersionNew(t *testing.T) {
	tempDirName, err := ioutil.TempDir("", "clientstore")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tempDirName)

	store, err := NewBoltSwapStore(tempDirName, &chaincfg.MainNetParams)
	if err != nil {
		t.Fatal(err)
	}

	ver, err := getDBVersion(store.db)
	if err != nil {
		t.Fatal(err)
	}

	if ver != latestDBVersion {
		t.Fatal("db not at latest version")
	}
}

// TestVersionNew tests that an existing version zero database is migrated to
// the latest version.
func TestVersionMigrated(t *testing.T) {
	tempDirName, err := ioutil.TempDir("", "clientstore")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tempDirName)

	createVersionZeroDb(t, tempDirName)

	store, err := NewBoltSwapStore(tempDirName, &chaincfg.MainNetParams)
	if err != nil {
		t.Fatal(err)
	}

	ver, err := getDBVersion(store.db)
	if err != nil {
		t.Fatal(err)
	}

	if ver != latestDBVersion {
		t.Fatal("db not at latest version")
	}
}

// createVersionZeroDb creates a database with an empty meta bucket. In version
// zero, there was no version key specified yet.
func createVersionZeroDb(t *testing.T, dbPath string) {
	path := filepath.Join(dbPath, dbFileName)
	bdb, err := bbolt.Open(path, 0600, nil)
	if err != nil {
		t.Fatal(err)
	}
	defer bdb.Close()

	err = bdb.Update(func(tx *bbolt.Tx) error {
		_, err := tx.CreateBucket(metaBucketKey)
		return err
	})
	if err != nil {
		t.Fatal(err)
	}
}

// TestLegacyOutgoingChannel asserts that a legacy channel restriction is
// properly mapped onto the newer channel set.
func TestLegacyOutgoingChannel(t *testing.T) {
	var (
		legacyDbVersion       = Hex("00000003")
		legacyOutgoingChannel = Hex("0000000000000005")
	)

	legacyDb := map[string]interface{}{
		"loop-in": map[string]interface{}{},
		"metadata": map[string]interface{}{
			"dbp": legacyDbVersion,
		},
		"uncharge-swaps": map[string]interface{}{
			Hex("2a595d79a55168970532805ae20c9b5fac98f04db79ba4c6ae9b9ac0f206359e"): map[string]interface{}{
				"contract": Hex("1562d6fbec140000010101010202020203030303040404040101010102020202030303030404040400000000000000640d707265706179696e766f69636501010101010101010101010101010101010101010101010101010101010101010201010101010101010101010101010101010101010101010101010101010101010300000090000000000000000a0000000000000014000000000000002800000063223347454e556d6e4552745766516374344e65676f6d557171745a757a5947507742530b73776170696e766f69636500000002000000000000001e") + legacyOutgoingChannel + Hex("1562d6fbec140000"),
				"updates": map[string]interface{}{
					Hex("0000000000000001"): Hex("1508290a92d4c00001000000000000000000000000000000000000000000000000"),
					Hex("0000000000000002"): Hex("1508290a92d4c00006000000000000000000000000000000000000000000000000"),
				},
			},
		},
	}

	// Restore a legacy database.
	tempDirName, err := ioutil.TempDir("", "clientstore")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tempDirName)

	tempPath := filepath.Join(tempDirName, dbFileName)
	db, err := bbolt.Open(tempPath, 0600, nil)
	if err != nil {
		t.Fatal(err)
	}
	err = db.Update(func(tx *bbolt.Tx) error {
		return RestoreDB(tx, legacyDb)
	})
	if err != nil {
		t.Fatal(err)
	}
	db.Close()

	// Fetch the legacy swap.
	store, err := NewBoltSwapStore(tempDirName, &chaincfg.MainNetParams)
	if err != nil {
		t.Fatal(err)
	}

	swaps, err := store.FetchLoopOutSwaps()
	if err != nil {
		t.Fatal(err)
	}

	// Assert that the outgoing channel is read properly.
	expectedChannelSet := ChannelSet{5}
	if !reflect.DeepEqual(swaps[0].Contract.OutgoingChanSet, expectedChannelSet) {
		t.Fatal("invalid outgoing channel")
	}
}