lotus/paychmgr/paych_test.go

package paychmgr

import (
	"bytes"
	"context"
	"testing"

	"github.com/ipfs/go-cid"
	ds "github.com/ipfs/go-datastore"
	ds_sync "github.com/ipfs/go-datastore/sync"
	"github.com/stretchr/testify/require"

	"github.com/filecoin-project/go-address"
	"github.com/filecoin-project/go-state-types/abi"
	"github.com/filecoin-project/go-state-types/big"
	"github.com/filecoin-project/go-state-types/crypto"
	"github.com/filecoin-project/specs-actors/actors/builtin"
	tutils "github.com/filecoin-project/specs-actors/support/testing"
	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"

	"github.com/filecoin-project/lotus/api"
	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
	paychmock "github.com/filecoin-project/lotus/chain/actors/builtin/paych/mock"
	"github.com/filecoin-project/lotus/chain/types"
	"github.com/filecoin-project/lotus/lib/sigs"
)

func TestCheckVoucherValid(t *testing.T) {
	ctx := context.Background()

	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)
	toKeyPrivate, toKeyPublic := testGenerateKeyPair(t)
	randKeyPrivate, _ := testGenerateKeyPair(t)

	ch := tutils.NewIDAddr(t, 100)
	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
	to := tutils.NewSECP256K1Addr(t, string(toKeyPublic))
	fromAcct := tutils.NewActorAddr(t, "fromAct")
	toAcct := tutils.NewActorAddr(t, "toAct")

	mock := newMockManagerAPI()
	mock.setAccountAddress(fromAcct, from)
	mock.setAccountAddress(toAcct, to)

	tcases := []struct {
		name          string
		expectError   bool
		key           []byte
		actorBalance  big.Int
		voucherAmount big.Int
		voucherLane   uint64
		voucherNonce  uint64
		laneStates    map[uint64]paych.LaneState
	}{{
		name:          "passes when voucher amount < balance",
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(5),
	}, {
		name:          "fails when funds too low",
		expectError:   true,
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(5),
		voucherAmount: big.NewInt(10),
	}, {
		name:          "fails when invalid signature",
		expectError:   true,
		key:           randKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(5),
	}, {
		name:          "fails when signed by channel To account (instead of From account)",
		expectError:   true,
		key:           toKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(5),
	}, {
		name:          "fails when nonce too low",
		expectError:   true,
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(5),
		voucherLane:   1,
		voucherNonce:  2,
		laneStates: map[uint64]paych.LaneState{
			1: paychmock.NewMockLaneState(big.NewInt(2), 3),
		},
	}, {
		name:          "passes when nonce higher",
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(5),
		voucherLane:   1,
		voucherNonce:  3,
		laneStates: map[uint64]paych.LaneState{
			1: paychmock.NewMockLaneState(big.NewInt(2), 2),
		},
	}, {
		name:          "passes when nonce for different lane",
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(5),
		voucherLane:   2,
		voucherNonce:  2,
		laneStates: map[uint64]paych.LaneState{
			1: paychmock.NewMockLaneState(big.NewInt(2), 3),
		},
	}, {
		name:          "fails when voucher has higher nonce but lower value than lane state",
		expectError:   true,
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(5),
		voucherLane:   1,
		voucherNonce:  3,
		laneStates: map[uint64]paych.LaneState{
			1: paychmock.NewMockLaneState(big.NewInt(6), 2),
		},
	}, {
		// voucher supersedes lane 1 redeemed so
		// lane 1 effective redeemed = voucher amount
		//
		// required balance = voucher amt
		//                  = 7
		// So required balance: 7 < actor balance: 10
		name:          "passes when voucher total redeemed <= balance",
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(6),
		voucherLane:   1,
		voucherNonce:  2,
		laneStates: map[uint64]paych.LaneState{
			// Lane 1 (same as voucher lane 1)
			1: paychmock.NewMockLaneState(big.NewInt(4), 1),
		},
	}, {
		// required balance = total redeemed
		//                  = 6 (voucher lane 1) + 5 (lane 2)
		//                  = 11
		// So required balance: 11 > actor balance: 10
		name:          "fails when voucher total redeemed > balance",
		expectError:   true,
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(6),
		voucherLane:   1,
		voucherNonce:  1,
		laneStates: map[uint64]paych.LaneState{
			// Lane 2 (different from voucher lane 1)
			2: paychmock.NewMockLaneState(big.NewInt(5), 1),
		},
	}, {
		// voucher supersedes lane 1 redeemed so
		// lane 1 effective redeemed = voucher amount
		//
		// required balance = total redeemed
		//                  = 6 (new voucher lane 1) + 5 (lane 2)
		//                  = 11
		// So required balance: 11 > actor balance: 10
		name:          "fails when voucher total redeemed > balance",
		expectError:   true,
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(6),
		voucherLane:   1,
		voucherNonce:  2,
		laneStates: map[uint64]paych.LaneState{
			// Lane 1 (superseded by new voucher in voucher lane 1)
			1: paychmock.NewMockLaneState(big.NewInt(5), 1),
			// Lane 2 (different from voucher lane 1)
			2: paychmock.NewMockLaneState(big.NewInt(5), 1),
		},
	}, {
		// voucher supersedes lane 1 redeemed so
		// lane 1 effective redeemed = voucher amount
		//
		// required balance = total redeemed
		//                  = 5 (new voucher lane 1) + 5 (lane 2)
		//                  = 10
		// So required balance: 10 <= actor balance: 10
		name:          "passes when voucher total redeemed <= balance",
		expectError:   false,
		key:           fromKeyPrivate,
		actorBalance:  big.NewInt(10),
		voucherAmount: big.NewInt(5),
		voucherLane:   1,
		voucherNonce:  2,
		laneStates: map[uint64]paych.LaneState{
			// Lane 1 (superseded by new voucher in voucher lane 1)
			1: paychmock.NewMockLaneState(big.NewInt(4), 1),
			// Lane 2 (different from voucher lane 1)
			2: paychmock.NewMockLaneState(big.NewInt(5), 1),
		},
	}}

	for _, tcase := range tcases {
		tcase := tcase
		t.Run(tcase.name, func(t *testing.T) {
			// Create an actor for the channel with the test case balance
			act := &types.Actor{
				Code:    builtin.AccountActorCodeID,
				Head:    cid.Cid{},
				Nonce:   0,
				Balance: tcase.actorBalance,
			}

			mock.setPaychState(ch, act, paychmock.NewMockPayChState(
				fromAcct, toAcct, abi.ChainEpoch(0), tcase.laneStates))

			// Create a manager
			store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
			mgr, err := newManager(store, mock)
			require.NoError(t, err)

			// Add channel To address to wallet
			mock.addWalletAddress(to)

			// Create the test case signed voucher
			sv := createTestVoucher(t, ch, tcase.voucherLane, tcase.voucherNonce, tcase.voucherAmount, tcase.key)

			// Check the voucher's validity
			err = mgr.CheckVoucherValid(ctx, ch, sv)
			if tcase.expectError {
				require.Error(t, err)
			} else {
				require.NoError(t, err)
			}
		})
	}
}

func TestCreateVoucher(t *testing.T) {
	ctx := context.Background()

	// Set up a manager with a single payment channel
	s := testSetupMgrWithChannel(t)

	// Create a voucher in lane 1
	voucherLane1Amt := big.NewInt(5)
	voucher := paych2.SignedVoucher{
		Lane:   1,
		Amount: voucherLane1Amt,
	}
	res, err := s.mgr.CreateVoucher(ctx, s.ch, voucher)
	require.NoError(t, err)
	require.NotNil(t, res.Voucher)
	require.Equal(t, s.ch, res.Voucher.ChannelAddr)
	require.Equal(t, voucherLane1Amt, res.Voucher.Amount)
	require.EqualValues(t, 0, res.Shortfall.Int64())

	nonce := res.Voucher.Nonce

	// Create a voucher in lane 1 again, with a higher amount
	voucherLane1Amt = big.NewInt(8)
	voucher = paych2.SignedVoucher{
		Lane:   1,
		Amount: voucherLane1Amt,
	}
	res, err = s.mgr.CreateVoucher(ctx, s.ch, voucher)
	require.NoError(t, err)
	require.NotNil(t, res.Voucher)
	require.Equal(t, s.ch, res.Voucher.ChannelAddr)
	require.Equal(t, voucherLane1Amt, res.Voucher.Amount)
	require.EqualValues(t, 0, res.Shortfall.Int64())
	require.Equal(t, nonce+1, res.Voucher.Nonce)

	// Create a voucher in lane 2 that covers all the remaining funds
	// in the channel
	voucherLane2Amt := big.Sub(s.amt, voucherLane1Amt)
	voucher = paych2.SignedVoucher{
		Lane:   2,
		Amount: voucherLane2Amt,
	}
	res, err = s.mgr.CreateVoucher(ctx, s.ch, voucher)
	require.NoError(t, err)
	require.NotNil(t, res.Voucher)
	require.Equal(t, s.ch, res.Voucher.ChannelAddr)
	require.Equal(t, voucherLane2Amt, res.Voucher.Amount)
	require.EqualValues(t, 0, res.Shortfall.Int64())

	// Create a voucher in lane 2 that exceeds the remaining funds in the
	// channel
	voucherLane2Amt = big.Add(voucherLane2Amt, big.NewInt(1))
	voucher = paych2.SignedVoucher{
		Lane:   2,
		Amount: voucherLane2Amt,
	}
	res, err = s.mgr.CreateVoucher(ctx, s.ch, voucher)
	require.NoError(t, err)

	// Expect a shortfall value equal to the amount required to add the voucher
	// to the channel
	require.Nil(t, res.Voucher)
	require.EqualValues(t, 1, res.Shortfall.Int64())
}

func TestAddVoucherDelta(t *testing.T) {
	ctx := context.Background()

	// Set up a manager with a single payment channel
	s := testSetupMgrWithChannel(t)

	voucherLane := uint64(1)

	// Expect error when adding a voucher whose amount is less than minDelta
	minDelta := big.NewInt(2)
	nonce := uint64(1)
	voucherAmount := big.NewInt(1)
	sv := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	_, err := s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
	require.Error(t, err)

	// Expect success when adding a voucher whose amount is equal to minDelta
	nonce++
	voucherAmount = big.NewInt(2)
	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	delta, err := s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
	require.NoError(t, err)
	require.EqualValues(t, delta.Int64(), 2)

	// Check that delta is correct when there's an existing voucher
	nonce++
	voucherAmount = big.NewInt(5)
	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	delta, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
	require.NoError(t, err)
	require.EqualValues(t, delta.Int64(), 3)

	// Check that delta is correct when voucher added to a different lane
	nonce = uint64(1)
	voucherAmount = big.NewInt(6)
	voucherLane = uint64(2)
	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	delta, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
	require.NoError(t, err)
	require.EqualValues(t, delta.Int64(), 6)
}

func TestAddVoucherNextLane(t *testing.T) {
	ctx := context.Background()

	// Set up a manager with a single payment channel
	s := testSetupMgrWithChannel(t)

	minDelta := big.NewInt(0)
	voucherAmount := big.NewInt(2)

	// Add a voucher in lane 2
	nonce := uint64(1)
	voucherLane := uint64(2)
	sv := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	_, err := s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
	require.NoError(t, err)

	ci, err := s.mgr.GetChannelInfo(s.ch)
	require.NoError(t, err)
	require.EqualValues(t, ci.NextLane, 3)

	// Allocate a lane (should be lane 3)
	lane, err := s.mgr.AllocateLane(s.ch)
	require.NoError(t, err)
	require.EqualValues(t, lane, 3)

	ci, err = s.mgr.GetChannelInfo(s.ch)
	require.NoError(t, err)
	require.EqualValues(t, ci.NextLane, 4)

	// Add a voucher in lane 1
	voucherLane = uint64(1)
	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	_, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
	require.NoError(t, err)

	ci, err = s.mgr.GetChannelInfo(s.ch)
	require.NoError(t, err)
	require.EqualValues(t, ci.NextLane, 4)

	// Add a voucher in lane 7
	voucherLane = uint64(7)
	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	_, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
	require.NoError(t, err)

	ci, err = s.mgr.GetChannelInfo(s.ch)
	require.NoError(t, err)
	require.EqualValues(t, ci.NextLane, 8)
}

func TestAllocateLane(t *testing.T) {
	// Set up a manager with a single payment channel
	s := testSetupMgrWithChannel(t)

	// First lane should be 0
	lane, err := s.mgr.AllocateLane(s.ch)
	require.NoError(t, err)
	require.EqualValues(t, lane, 0)

	// Next lane should be 1
	lane, err = s.mgr.AllocateLane(s.ch)
	require.NoError(t, err)
	require.EqualValues(t, lane, 1)
}

func TestAllocateLaneWithExistingLaneState(t *testing.T) {
	ctx := context.Background()

	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)

	ch := tutils.NewIDAddr(t, 100)
	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
	to := tutils.NewSECP256K1Addr(t, "secpTo")
	fromAcct := tutils.NewActorAddr(t, "fromAct")
	toAcct := tutils.NewActorAddr(t, "toAct")

	mock := newMockManagerAPI()
	mock.setAccountAddress(fromAcct, from)
	mock.setAccountAddress(toAcct, to)
	mock.addWalletAddress(to)

	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))

	// Create a channel that will be retrieved from state
	actorBalance := big.NewInt(10)

	act := &types.Actor{
		Code:    builtin.AccountActorCodeID,
		Head:    cid.Cid{},
		Nonce:   0,
		Balance: actorBalance,
	}

	mock.setPaychState(ch, act, paychmock.NewMockPayChState(fromAcct, toAcct, abi.ChainEpoch(0), make(map[uint64]paych.LaneState)))

	mgr, err := newManager(store, mock)
	require.NoError(t, err)

	// Create a voucher on lane 2
	// (also reads the channel from state and puts it in the store)
	voucherLane := uint64(2)
	minDelta := big.NewInt(0)
	nonce := uint64(2)
	voucherAmount := big.NewInt(5)
	sv := createTestVoucher(t, ch, voucherLane, nonce, voucherAmount, fromKeyPrivate)
	_, err = mgr.AddVoucherInbound(ctx, ch, sv, nil, minDelta)
	require.NoError(t, err)

	// Allocate lane should return the next lane (lane 3)
	lane, err := mgr.AllocateLane(ch)
	require.NoError(t, err)
	require.EqualValues(t, 3, lane)
}

func TestAddVoucherInboundWalletKey(t *testing.T) {
	ctx := context.Background()

	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)

	ch := tutils.NewIDAddr(t, 100)
	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
	to := tutils.NewSECP256K1Addr(t, "secpTo")
	fromAcct := tutils.NewActorAddr(t, "fromAct")
	toAcct := tutils.NewActorAddr(t, "toAct")

	// Create an actor for the channel in state
	act := &types.Actor{
		Code:    builtin.AccountActorCodeID,
		Head:    cid.Cid{},
		Nonce:   0,
		Balance: types.NewInt(20),
	}

	mock := newMockManagerAPI()

	mock.setAccountAddress(fromAcct, from)
	mock.setAccountAddress(toAcct, to)

	mock.setPaychState(ch, act, paychmock.NewMockPayChState(fromAcct, toAcct, abi.ChainEpoch(0), make(map[uint64]paych.LaneState)))

	// Create a manager
	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
	mgr, err := newManager(store, mock)
	require.NoError(t, err)

	// Add a voucher
	nonce := uint64(1)
	voucherLane := uint64(1)
	minDelta := big.NewInt(0)
	voucherAmount := big.NewInt(2)
	sv := createTestVoucher(t, ch, voucherLane, nonce, voucherAmount, fromKeyPrivate)
	_, err = mgr.AddVoucherInbound(ctx, ch, sv, nil, minDelta)

	// Should fail because there is no wallet key matching the channel To
	// address (ie, the channel is not "owned" by this node)
	require.Error(t, err)

	// Add wallet key for To address
	mock.addWalletAddress(to)

	// Add voucher again
	sv = createTestVoucher(t, ch, voucherLane, nonce, voucherAmount, fromKeyPrivate)
	_, err = mgr.AddVoucherInbound(ctx, ch, sv, nil, minDelta)

	// Should now pass because there is a wallet key matching the channel To
	// address
	require.NoError(t, err)
}

func TestBestSpendable(t *testing.T) {
	ctx := context.Background()

	// Set up a manager with a single payment channel
	s := testSetupMgrWithChannel(t)

	// Add vouchers to lane 1 with amounts: [1, 2, 3]
	voucherLane := uint64(1)
	minDelta := big.NewInt(0)
	nonce := uint64(1)
	voucherAmount := big.NewInt(1)
	svL1V1 := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	_, err := s.mgr.AddVoucherInbound(ctx, s.ch, svL1V1, nil, minDelta)
	require.NoError(t, err)

	nonce++
	voucherAmount = big.NewInt(2)
	svL1V2 := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	_, err = s.mgr.AddVoucherInbound(ctx, s.ch, svL1V2, nil, minDelta)
	require.NoError(t, err)

	nonce++
	voucherAmount = big.NewInt(3)
	svL1V3 := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	_, err = s.mgr.AddVoucherInbound(ctx, s.ch, svL1V3, nil, minDelta)
	require.NoError(t, err)

	// Add voucher to lane 2 with amounts: [2]
	voucherLane = uint64(2)
	nonce = uint64(1)
	voucherAmount = big.NewInt(2)
	svL2V1 := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	_, err = s.mgr.AddVoucherInbound(ctx, s.ch, svL2V1, nil, minDelta)
	require.NoError(t, err)

	// Return success exit code from calls to check if voucher is spendable
	bsapi := newMockBestSpendableAPI(s.mgr)
	s.mock.setCallResponse(&api.InvocResult{
		MsgRct: &types.MessageReceipt{
			ExitCode: 0,
		},
	})

	// Verify best spendable vouchers on each lane
	vouchers, err := BestSpendableByLane(ctx, bsapi, s.ch)
	require.NoError(t, err)
	require.Len(t, vouchers, 2)

	vchr, ok := vouchers[1]
	require.True(t, ok)
	require.EqualValues(t, 3, vchr.Amount.Int64())

	vchr, ok = vouchers[2]
	require.True(t, ok)
	require.EqualValues(t, 2, vchr.Amount.Int64())

	// Submit voucher from lane 2
	_, err = s.mgr.SubmitVoucher(ctx, s.ch, svL2V1, nil, nil)
	require.NoError(t, err)

	// Best spendable voucher should no longer include lane 2
	// (because voucher has not been submitted)
	vouchers, err = BestSpendableByLane(ctx, bsapi, s.ch)
	require.NoError(t, err)
	require.Len(t, vouchers, 1)

	// Submit first voucher from lane 1
	_, err = s.mgr.SubmitVoucher(ctx, s.ch, svL1V1, nil, nil)
	require.NoError(t, err)

	// Best spendable voucher for lane 1 should still be highest value voucher
	vouchers, err = BestSpendableByLane(ctx, bsapi, s.ch)
	require.NoError(t, err)
	require.Len(t, vouchers, 1)

	vchr, ok = vouchers[1]
	require.True(t, ok)
	require.EqualValues(t, 3, vchr.Amount.Int64())
}

func TestCheckSpendable(t *testing.T) {
	ctx := context.Background()

	// Set up a manager with a single payment channel
	s := testSetupMgrWithChannel(t)

	// Create voucher with Extra
	voucherLane := uint64(1)
	nonce := uint64(1)
	voucherAmount := big.NewInt(1)
	voucher := createTestVoucherWithExtra(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)

	// Add voucher
	minDelta := big.NewInt(0)
	_, err := s.mgr.AddVoucherInbound(ctx, s.ch, voucher, nil, minDelta)
	require.NoError(t, err)

	// Return success exit code from VM call, which indicates that voucher is
	// spendable
	successResponse := &api.InvocResult{
		MsgRct: &types.MessageReceipt{
			ExitCode: 0,
		},
	}
	s.mock.setCallResponse(successResponse)

	// Check that spendable is true
	secret := []byte("secret")
	spendable, err := s.mgr.CheckVoucherSpendable(ctx, s.ch, voucher, secret, nil)
	require.NoError(t, err)
	require.True(t, spendable)

	// Check that the secret was passed through correctly
	lastCall := s.mock.getLastCall()
	var p paych2.UpdateChannelStateParams
	err = p.UnmarshalCBOR(bytes.NewReader(lastCall.Params))
	require.NoError(t, err)
	require.Equal(t, secret, p.Secret)

	// Check that if VM call returns non-success exit code, spendable is false
	s.mock.setCallResponse(&api.InvocResult{
		MsgRct: &types.MessageReceipt{
			ExitCode: 1,
		},
	})
	spendable, err = s.mgr.CheckVoucherSpendable(ctx, s.ch, voucher, secret, nil)
	require.NoError(t, err)
	require.False(t, spendable)

	// Return success exit code (indicating voucher is spendable)
	s.mock.setCallResponse(successResponse)
	spendable, err = s.mgr.CheckVoucherSpendable(ctx, s.ch, voucher, secret, nil)
	require.NoError(t, err)
	require.True(t, spendable)

	// Check that voucher is no longer spendable once it has been submitted
	_, err = s.mgr.SubmitVoucher(ctx, s.ch, voucher, nil, nil)
	require.NoError(t, err)

	spendable, err = s.mgr.CheckVoucherSpendable(ctx, s.ch, voucher, secret, nil)
	require.NoError(t, err)
	require.False(t, spendable)
}

func TestSubmitVoucher(t *testing.T) {
	ctx := context.Background()

	// Set up a manager with a single payment channel
	s := testSetupMgrWithChannel(t)

	// Create voucher with Extra
	voucherLane := uint64(1)
	nonce := uint64(1)
	voucherAmount := big.NewInt(1)
	voucher := createTestVoucherWithExtra(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)

	// Add voucher
	minDelta := big.NewInt(0)
	_, err := s.mgr.AddVoucherInbound(ctx, s.ch, voucher, nil, minDelta)
	require.NoError(t, err)

	// Submit voucher
	secret := []byte("secret")
	submitCid, err := s.mgr.SubmitVoucher(ctx, s.ch, voucher, secret, nil)
	require.NoError(t, err)

	// Check that the secret was passed through correctly
	msg := s.mock.pushedMessages(submitCid)
	var p paych2.UpdateChannelStateParams
	err = p.UnmarshalCBOR(bytes.NewReader(msg.Message.Params))
	require.NoError(t, err)
	require.Equal(t, secret, p.Secret)

	// Submit a voucher without first adding it
	nonce++
	voucherAmount = big.NewInt(3)
	secret3 := []byte("secret2")
	voucher = createTestVoucherWithExtra(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
	submitCid, err = s.mgr.SubmitVoucher(ctx, s.ch, voucher, secret3, nil)
	require.NoError(t, err)

	msg = s.mock.pushedMessages(submitCid)
	var p3 paych2.UpdateChannelStateParams
	err = p3.UnmarshalCBOR(bytes.NewReader(msg.Message.Params))
	require.NoError(t, err)
	require.Equal(t, secret3, p3.Secret)

	// Verify that vouchers are marked as submitted
	vis, err := s.mgr.ListVouchers(ctx, s.ch)
	require.NoError(t, err)
	require.Len(t, vis, 2)

	for _, vi := range vis {
		require.True(t, vi.Submitted)
	}

	// Attempting to submit the same voucher again should fail
	_, err = s.mgr.SubmitVoucher(ctx, s.ch, voucher, secret3, nil)
	require.Error(t, err)
}

type testScaffold struct {
	mgr            *Manager
	mock           *mockManagerAPI
	ch             address.Address
	amt            big.Int
	fromAcct       address.Address
	fromKeyPrivate []byte
}

func testSetupMgrWithChannel(t *testing.T) *testScaffold {
	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)

	ch := tutils.NewIDAddr(t, 100)
	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
	to := tutils.NewSECP256K1Addr(t, "secpTo")
	fromAcct := tutils.NewActorAddr(t, "fromAct")
	toAcct := tutils.NewActorAddr(t, "toAct")

	mock := newMockManagerAPI()
	mock.setAccountAddress(fromAcct, from)
	mock.setAccountAddress(toAcct, to)

	// Create channel in state
	balance := big.NewInt(20)
	act := &types.Actor{
		Code:    builtin.AccountActorCodeID,
		Head:    cid.Cid{},
		Nonce:   0,
		Balance: balance,
	}
	mock.setPaychState(ch, act, paychmock.NewMockPayChState(fromAcct, toAcct, abi.ChainEpoch(0), make(map[uint64]paych.LaneState)))

	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
	mgr, err := newManager(store, mock)
	require.NoError(t, err)

	// Create the channel in the manager's store
	ci := &ChannelInfo{
		Channel:   &ch,
		Control:   fromAcct,
		Target:    toAcct,
		Direction: DirOutbound,
	}
	err = mgr.store.putChannelInfo(ci)
	require.NoError(t, err)

	// Add the from signing key to the wallet
	mock.addSigningKey(fromKeyPrivate)

	return &testScaffold{
		mgr:            mgr,
		mock:           mock,
		ch:             ch,
		amt:            balance,
		fromAcct:       fromAcct,
		fromKeyPrivate: fromKeyPrivate,
	}
}

func testGenerateKeyPair(t *testing.T) ([]byte, []byte) {
	priv, err := sigs.Generate(crypto.SigTypeSecp256k1)
	require.NoError(t, err)
	pub, err := sigs.ToPublic(crypto.SigTypeSecp256k1, priv)
	require.NoError(t, err)
	return priv, pub
}

func createTestVoucher(t *testing.T, ch address.Address, voucherLane uint64, nonce uint64, voucherAmount big.Int, key []byte) *paych2.SignedVoucher {
	sv := &paych2.SignedVoucher{
		ChannelAddr: ch,
		Lane:        voucherLane,
		Nonce:       nonce,
		Amount:      voucherAmount,
	}

	signingBytes, err := sv.SigningBytes()
	require.NoError(t, err)
	sig, err := sigs.Sign(crypto.SigTypeSecp256k1, key, signingBytes)
	require.NoError(t, err)
	sv.Signature = sig
	return sv
}

func createTestVoucherWithExtra(t *testing.T, ch address.Address, voucherLane uint64, nonce uint64, voucherAmount big.Int, key []byte) *paych2.SignedVoucher {
	sv := &paych2.SignedVoucher{
		ChannelAddr: ch,
		Lane:        voucherLane,
		Nonce:       nonce,
		Amount:      voucherAmount,
		Extra: &paych2.ModVerifyParams{
			Actor: tutils.NewActorAddr(t, "act"),
		},
	}

	signingBytes, err := sv.SigningBytes()
	require.NoError(t, err)
	sig, err := sigs.Sign(crypto.SigTypeSecp256k1, key, signingBytes)
	require.NoError(t, err)
	sv.Signature = sig

	return sv
}

type mockBestSpendableAPI struct {
	mgr *Manager
}

func (m *mockBestSpendableAPI) PaychVoucherList(ctx context.Context, ch address.Address) ([]*paych2.SignedVoucher, error) {
	vi, err := m.mgr.ListVouchers(ctx, ch)
	if err != nil {
		return nil, err
	}

	out := make([]*paych2.SignedVoucher, len(vi))
	for k, v := range vi {
		out[k] = v.Voucher
	}

	return out, nil
}

func (m *mockBestSpendableAPI) PaychVoucherCheckSpendable(ctx context.Context, ch address.Address, voucher *paych2.SignedVoucher, secret []byte, proof []byte) (bool, error) {
	return m.mgr.CheckVoucherSpendable(ctx, ch, voucher, secret, proof)
}

func newMockBestSpendableAPI(mgr *Manager) BestSpendableAPI {
	return &mockBestSpendableAPI{mgr: mgr}
}