lotus/itests/paych_cli_test.go

431 lines
15 KiB
Go
Raw Normal View History

2021-05-17 12:28:09 +00:00
package itests
2020-08-13 20:37:09 +00:00
import (
"context"
2020-08-18 15:27:00 +00:00
"fmt"
2020-08-13 20:37:09 +00:00
"os"
2020-09-01 14:33:44 +00:00
"regexp"
2020-08-13 20:37:09 +00:00
"strconv"
"strings"
"testing"
"time"
2021-05-17 12:28:09 +00:00
"github.com/filecoin-project/lotus/cli"
2021-06-18 18:45:29 +00:00
"github.com/filecoin-project/lotus/itests/kit"
2020-08-13 20:37:09 +00:00
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
2020-10-26 11:01:33 +00:00
cbor "github.com/ipfs/go-ipld-cbor"
"github.com/stretchr/testify/require"
2020-08-13 20:37:09 +00:00
"github.com/filecoin-project/lotus/blockstore"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/events"
"github.com/filecoin-project/lotus/chain/types"
2020-08-13 20:37:09 +00:00
)
2021-06-23 10:44:52 +00:00
// TestPaymentChannelsBasic does a basic test to exercise the payment channel CLI
2020-08-13 20:37:09 +00:00
// commands
func TestPaymentChannelsBasic(t *testing.T) {
2020-08-13 20:37:09 +00:00
_ = os.Setenv("BELLMAN_NO_GPU", "1")
2021-06-18 18:45:29 +00:00
kit.QuietMiningLogs()
2020-08-13 20:37:09 +00:00
blocktime := 5 * time.Millisecond
ctx := context.Background()
var (
2021-06-18 18:45:29 +00:00
paymentCreator kit.TestFullNode
paymentReceiver kit.TestFullNode
)
creatorAddr, receiverAddr := startPaychCreatorReceiverMiner(ctx, t, &paymentCreator, &paymentReceiver, blocktime)
2020-08-18 15:27:00 +00:00
// Create mock CLI
2021-06-18 18:45:29 +00:00
mockCLI := kit.NewMockCLI(ctx, t, cli.Commands)
2020-10-26 11:01:33 +00:00
creatorCLI := mockCLI.Client(paymentCreator.ListenAddr)
receiverCLI := mockCLI.Client(paymentReceiver.ListenAddr)
2020-08-18 15:27:00 +00:00
// creator: paych add-funds <creator> <receiver> <amount>
2020-08-18 15:27:00 +00:00
channelAmt := "100000"
2020-10-26 13:26:46 +00:00
chstr := creatorCLI.RunCmd("paych", "add-funds", creatorAddr.String(), receiverAddr.String(), channelAmt)
2020-08-18 15:27:00 +00:00
chAddr, err := address.NewFromString(chstr)
require.NoError(t, err)
// creator: paych voucher create <channel> <amount>
voucherAmt := 100
vamt := strconv.Itoa(voucherAmt)
2020-10-26 13:26:46 +00:00
voucher := creatorCLI.RunCmd("paych", "voucher", "create", chAddr.String(), vamt)
2020-08-18 15:27:00 +00:00
// receiver: paych voucher add <channel> <voucher>
2020-10-26 13:26:46 +00:00
receiverCLI.RunCmd("paych", "voucher", "add", chAddr.String(), voucher)
2020-08-18 15:27:00 +00:00
// creator: paych settle <channel>
2020-10-26 13:26:46 +00:00
creatorCLI.RunCmd("paych", "settle", chAddr.String())
2020-08-18 15:27:00 +00:00
t.Log("wait for chain to reach settle height")
2020-08-18 15:27:00 +00:00
// Wait for the chain to reach the settle height
chState := getPaychState(ctx, t, paymentReceiver, chAddr)
sa, err := chState.SettlingAt()
require.NoError(t, err)
waitForHeight(ctx, t, paymentReceiver, sa)
2020-08-18 15:27:00 +00:00
t.Log("settle height reached")
2020-08-18 15:27:00 +00:00
// receiver: paych collect <channel>
2020-10-26 13:26:46 +00:00
receiverCLI.RunCmd("paych", "collect", chAddr.String())
2020-08-18 15:27:00 +00:00
}
type voucherSpec struct {
serialized string
amt int
lane int
}
// TestPaymentChannelStatus tests the payment channel status CLI command
func TestPaymentChannelStatus(t *testing.T) {
_ = os.Setenv("BELLMAN_NO_GPU", "1")
2021-06-18 18:45:29 +00:00
kit.QuietMiningLogs()
blocktime := 5 * time.Millisecond
ctx := context.Background()
var (
2021-06-18 18:45:29 +00:00
paymentCreator kit.TestFullNode
paymentReceiver kit.TestFullNode
)
creatorAddr, receiverAddr := startPaychCreatorReceiverMiner(ctx, t, &paymentCreator, &paymentReceiver, blocktime)
// Create mock CLI
2021-06-18 18:45:29 +00:00
mockCLI := kit.NewMockCLI(ctx, t, cli.Commands)
2020-10-26 11:01:33 +00:00
creatorCLI := mockCLI.Client(paymentCreator.ListenAddr)
2020-10-26 11:01:33 +00:00
// creator: paych status-by-from-to <creator> <receiver>
2020-10-26 13:26:46 +00:00
out := creatorCLI.RunCmd("paych", "status-by-from-to", creatorAddr.String(), receiverAddr.String())
fmt.Println(out)
noChannelState := "Channel does not exist"
require.Regexp(t, regexp.MustCompile(noChannelState), out)
channelAmt := uint64(100)
create := make(chan string)
go func() {
// creator: paych add-funds <creator> <receiver> <amount>
2020-10-26 13:26:46 +00:00
create <- creatorCLI.RunCmd(
"paych",
"add-funds",
creatorAddr.String(),
receiverAddr.String(),
fmt.Sprintf("%d", channelAmt))
}()
// Wait for the output to stop being "Channel does not exist"
for regexp.MustCompile(noChannelState).MatchString(out) {
2020-10-26 13:26:46 +00:00
out = creatorCLI.RunCmd("paych", "status-by-from-to", creatorAddr.String(), receiverAddr.String())
}
fmt.Println(out)
// The next state should be creating channel or channel created, depending
// on timing
stateCreating := regexp.MustCompile("Creating channel").MatchString(out)
stateCreated := regexp.MustCompile("Channel exists").MatchString(out)
require.True(t, stateCreating || stateCreated)
channelAmtAtto := types.BigMul(types.NewInt(channelAmt), types.NewInt(build.FilecoinPrecision))
channelAmtStr := fmt.Sprintf("%d", channelAmtAtto)
if stateCreating {
// If we're in the creating state (most likely) the amount should be pending
require.Regexp(t, regexp.MustCompile("Pending.*"+channelAmtStr), out)
}
// Wait for create channel to complete
chstr := <-create
2020-10-26 13:26:46 +00:00
out = creatorCLI.RunCmd("paych", "status", chstr)
fmt.Println(out)
// Output should have the channel address
require.Regexp(t, regexp.MustCompile("Channel.*"+chstr), out)
// Output should have confirmed amount
require.Regexp(t, regexp.MustCompile("Confirmed.*"+channelAmtStr), out)
chAddr, err := address.NewFromString(chstr)
require.NoError(t, err)
// creator: paych voucher create <channel> <amount>
voucherAmt := uint64(10)
2020-10-26 13:26:46 +00:00
creatorCLI.RunCmd("paych", "voucher", "create", chAddr.String(), fmt.Sprintf("%d", voucherAmt))
2020-10-26 13:26:46 +00:00
out = creatorCLI.RunCmd("paych", "status", chstr)
fmt.Println(out)
voucherAmtAtto := types.BigMul(types.NewInt(voucherAmt), types.NewInt(build.FilecoinPrecision))
voucherAmtStr := fmt.Sprintf("%d", voucherAmtAtto)
// Output should include voucher amount
require.Regexp(t, regexp.MustCompile("Voucher.*"+voucherAmtStr), out)
}
2020-08-18 15:27:00 +00:00
// TestPaymentChannelVouchers does a basic test to exercise some payment
// channel voucher commands
func TestPaymentChannelVouchers(t *testing.T) {
_ = os.Setenv("BELLMAN_NO_GPU", "1")
2021-06-18 18:45:29 +00:00
kit.QuietMiningLogs()
2020-08-18 15:27:00 +00:00
blocktime := 5 * time.Millisecond
ctx := context.Background()
var (
2021-06-18 18:45:29 +00:00
paymentCreator kit.TestFullNode
paymentReceiver kit.TestFullNode
)
creatorAddr, receiverAddr := startPaychCreatorReceiverMiner(ctx, t, &paymentCreator, &paymentReceiver, blocktime)
2020-08-18 15:27:00 +00:00
// Create mock CLI
2021-06-18 18:45:29 +00:00
mockCLI := kit.NewMockCLI(ctx, t, cli.Commands)
2020-10-26 11:01:33 +00:00
creatorCLI := mockCLI.Client(paymentCreator.ListenAddr)
receiverCLI := mockCLI.Client(paymentReceiver.ListenAddr)
2020-08-18 15:27:00 +00:00
// creator: paych add-funds <creator> <receiver> <amount>
2020-08-18 15:27:00 +00:00
channelAmt := "100000"
2020-10-26 13:26:46 +00:00
chstr := creatorCLI.RunCmd("paych", "add-funds", creatorAddr.String(), receiverAddr.String(), channelAmt)
2020-08-18 15:27:00 +00:00
chAddr, err := address.NewFromString(chstr)
require.NoError(t, err)
var vouchers []voucherSpec
// creator: paych voucher create <channel> <amount>
// Note: implied --lane=0
voucherAmt1 := 100
2020-10-26 13:26:46 +00:00
voucher1 := creatorCLI.RunCmd("paych", "voucher", "create", chAddr.String(), strconv.Itoa(voucherAmt1))
2020-08-18 15:27:00 +00:00
vouchers = append(vouchers, voucherSpec{serialized: voucher1, lane: 0, amt: voucherAmt1})
// creator: paych voucher create <channel> <amount> --lane=5
lane5 := "--lane=5"
voucherAmt2 := 50
2020-10-26 13:26:46 +00:00
voucher2 := creatorCLI.RunCmd("paych", "voucher", "create", lane5, chAddr.String(), strconv.Itoa(voucherAmt2))
2020-08-18 15:27:00 +00:00
vouchers = append(vouchers, voucherSpec{serialized: voucher2, lane: 5, amt: voucherAmt2})
// creator: paych voucher create <channel> <amount> --lane=5
voucherAmt3 := 70
2020-10-26 13:26:46 +00:00
voucher3 := creatorCLI.RunCmd("paych", "voucher", "create", lane5, chAddr.String(), strconv.Itoa(voucherAmt3))
2020-08-18 15:27:00 +00:00
vouchers = append(vouchers, voucherSpec{serialized: voucher3, lane: 5, amt: voucherAmt3})
// creator: paych voucher create <channel> <amount> --lane=5
voucherAmt4 := 80
2020-10-26 13:26:46 +00:00
voucher4 := creatorCLI.RunCmd("paych", "voucher", "create", lane5, chAddr.String(), strconv.Itoa(voucherAmt4))
vouchers = append(vouchers, voucherSpec{serialized: voucher4, lane: 5, amt: voucherAmt4})
2020-08-18 15:27:00 +00:00
// creator: paych voucher list <channel> --export
2020-10-26 13:26:46 +00:00
list := creatorCLI.RunCmd("paych", "voucher", "list", "--export", chAddr.String())
2020-08-18 15:27:00 +00:00
// Check that voucher list output is correct on creator
2020-08-18 15:27:00 +00:00
checkVoucherOutput(t, list, vouchers)
// creator: paych voucher best-spendable <channel>
2020-10-26 13:26:46 +00:00
bestSpendable := creatorCLI.RunCmd("paych", "voucher", "best-spendable", "--export", chAddr.String())
2020-08-18 15:27:00 +00:00
// Check that best spendable output is correct on creator
2020-08-18 15:27:00 +00:00
bestVouchers := []voucherSpec{
{serialized: voucher1, lane: 0, amt: voucherAmt1},
{serialized: voucher4, lane: 5, amt: voucherAmt4},
2020-08-18 15:27:00 +00:00
}
checkVoucherOutput(t, bestSpendable, bestVouchers)
// receiver: paych voucher add <voucher>
2020-10-26 13:26:46 +00:00
receiverCLI.RunCmd("paych", "voucher", "add", chAddr.String(), voucher1)
// receiver: paych voucher add <voucher>
2020-10-26 13:26:46 +00:00
receiverCLI.RunCmd("paych", "voucher", "add", chAddr.String(), voucher2)
// receiver: paych voucher add <voucher>
2020-10-26 13:26:46 +00:00
receiverCLI.RunCmd("paych", "voucher", "add", chAddr.String(), voucher3)
// receiver: paych voucher add <voucher>
2020-10-26 13:26:46 +00:00
receiverCLI.RunCmd("paych", "voucher", "add", chAddr.String(), voucher4)
// receiver: paych voucher list <channel> --export
2020-10-26 13:26:46 +00:00
list = receiverCLI.RunCmd("paych", "voucher", "list", "--export", chAddr.String())
// Check that voucher list output is correct on receiver
checkVoucherOutput(t, list, vouchers)
// receiver: paych voucher best-spendable <channel>
2020-10-26 13:26:46 +00:00
bestSpendable = receiverCLI.RunCmd("paych", "voucher", "best-spendable", "--export", chAddr.String())
// Check that best spendable output is correct on receiver
bestVouchers = []voucherSpec{
{serialized: voucher1, lane: 0, amt: voucherAmt1},
{serialized: voucher4, lane: 5, amt: voucherAmt4},
}
checkVoucherOutput(t, bestSpendable, bestVouchers)
// receiver: paych voucher submit <channel> <voucher>
2020-10-26 13:26:46 +00:00
receiverCLI.RunCmd("paych", "voucher", "submit", chAddr.String(), voucher1)
// receiver: paych voucher best-spendable <channel>
2020-10-26 13:26:46 +00:00
bestSpendable = receiverCLI.RunCmd("paych", "voucher", "best-spendable", "--export", chAddr.String())
// Check that best spendable output no longer includes submitted voucher
bestVouchers = []voucherSpec{
{serialized: voucher4, lane: 5, amt: voucherAmt4},
}
checkVoucherOutput(t, bestSpendable, bestVouchers)
// There are three vouchers in lane 5: 50, 70, 80
// Submit the voucher for 50. Best spendable should still be 80.
// receiver: paych voucher submit <channel> <voucher>
2020-10-26 13:26:46 +00:00
receiverCLI.RunCmd("paych", "voucher", "submit", chAddr.String(), voucher2)
// receiver: paych voucher best-spendable <channel>
2020-10-26 13:26:46 +00:00
bestSpendable = receiverCLI.RunCmd("paych", "voucher", "best-spendable", "--export", chAddr.String())
// Check that best spendable output still includes the voucher for 80
bestVouchers = []voucherSpec{
{serialized: voucher4, lane: 5, amt: voucherAmt4},
}
checkVoucherOutput(t, bestSpendable, bestVouchers)
// Submit the voucher for 80
// receiver: paych voucher submit <channel> <voucher>
2020-10-26 13:26:46 +00:00
receiverCLI.RunCmd("paych", "voucher", "submit", chAddr.String(), voucher4)
// receiver: paych voucher best-spendable <channel>
2020-10-26 13:26:46 +00:00
bestSpendable = receiverCLI.RunCmd("paych", "voucher", "best-spendable", "--export", chAddr.String())
// Check that best spendable output no longer includes submitted voucher
bestVouchers = []voucherSpec{}
checkVoucherOutput(t, bestSpendable, bestVouchers)
2020-08-18 15:27:00 +00:00
}
2020-09-01 14:33:44 +00:00
// TestPaymentChannelVoucherCreateShortfall verifies that if a voucher amount
// is greater than what's left in the channel, voucher create fails
func TestPaymentChannelVoucherCreateShortfall(t *testing.T) {
_ = os.Setenv("BELLMAN_NO_GPU", "1")
2021-06-18 18:45:29 +00:00
kit.QuietMiningLogs()
2020-09-01 14:33:44 +00:00
blocktime := 5 * time.Millisecond
ctx := context.Background()
var (
2021-06-18 18:45:29 +00:00
paymentCreator kit.TestFullNode
paymentReceiver kit.TestFullNode
)
creatorAddr, receiverAddr := startPaychCreatorReceiverMiner(ctx, t, &paymentCreator, &paymentReceiver, blocktime)
2020-09-01 14:33:44 +00:00
// Create mock CLI
2021-06-18 18:45:29 +00:00
mockCLI := kit.NewMockCLI(ctx, t, cli.Commands)
2020-10-26 11:01:33 +00:00
creatorCLI := mockCLI.Client(paymentCreator.ListenAddr)
2020-09-01 14:33:44 +00:00
// creator: paych add-funds <creator> <receiver> <amount>
2020-09-01 14:33:44 +00:00
channelAmt := 100
2020-10-26 13:26:46 +00:00
chstr := creatorCLI.RunCmd(
"paych",
"add-funds",
creatorAddr.String(),
receiverAddr.String(),
fmt.Sprintf("%d", channelAmt))
2020-09-01 14:33:44 +00:00
chAddr, err := address.NewFromString(chstr)
require.NoError(t, err)
// creator: paych voucher create <channel> <amount> --lane=1
voucherAmt1 := 60
lane1 := "--lane=1"
2020-10-26 13:26:46 +00:00
voucher1 := creatorCLI.RunCmd(
"paych",
"voucher",
"create",
lane1,
chAddr.String(),
strconv.Itoa(voucherAmt1))
2020-09-01 14:33:44 +00:00
fmt.Println(voucher1)
// creator: paych voucher create <channel> <amount> --lane=2
lane2 := "--lane=2"
voucherAmt2 := 70
2020-10-26 13:26:46 +00:00
_, err = creatorCLI.RunCmdRaw(
"paych",
"voucher",
"create",
lane2,
chAddr.String(),
strconv.Itoa(voucherAmt2))
2020-09-01 14:33:44 +00:00
// Should fail because channel doesn't have required amount
require.Error(t, err)
shortfall := voucherAmt1 + voucherAmt2 - channelAmt
require.Regexp(t, regexp.MustCompile(fmt.Sprintf("shortfall: %d", shortfall)), err.Error())
}
2020-08-18 15:27:00 +00:00
func checkVoucherOutput(t *testing.T, list string, vouchers []voucherSpec) {
lines := strings.Split(list, "\n")
listVouchers := make(map[string]string)
for _, line := range lines {
parts := strings.Split(line, ";")
if len(parts) == 2 {
serialized := strings.TrimSpace(parts[1])
listVouchers[serialized] = strings.TrimSpace(parts[0])
}
2020-08-18 15:27:00 +00:00
}
for _, vchr := range vouchers {
res, ok := listVouchers[vchr.serialized]
require.True(t, ok)
require.Regexp(t, fmt.Sprintf("Lane %d", vchr.lane), res)
require.Regexp(t, fmt.Sprintf("%d", vchr.amt), res)
delete(listVouchers, vchr.serialized)
}
for _, vchr := range listVouchers {
require.Fail(t, "Extra voucher "+vchr)
2020-08-18 15:27:00 +00:00
}
}
2020-08-13 20:37:09 +00:00
// waitForHeight waits for the node to reach the given chain epoch
2021-06-18 18:45:29 +00:00
func waitForHeight(ctx context.Context, t *testing.T, node kit.TestFullNode, height abi.ChainEpoch) {
2020-08-13 20:37:09 +00:00
atHeight := make(chan struct{})
chainEvents := events.NewEvents(ctx, node)
err := chainEvents.ChainAt(func(ctx context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
close(atHeight)
return nil
}, nil, 1, height)
if err != nil {
t.Fatal(err)
}
select {
case <-atHeight:
case <-ctx.Done():
}
}
// getPaychState gets the state of the payment channel with the given address
2021-06-18 18:45:29 +00:00
func getPaychState(ctx context.Context, t *testing.T, node kit.TestFullNode, chAddr address.Address) paych.State {
2020-08-13 20:37:09 +00:00
act, err := node.StateGetActor(ctx, chAddr, types.EmptyTSK)
require.NoError(t, err)
store := cbor.NewCborStore(blockstore.NewAPIBlockstore(node))
chState, err := paych.Load(adt.WrapStore(ctx, store), act)
2020-08-13 20:37:09 +00:00
require.NoError(t, err)
return chState
}
2021-06-18 18:45:29 +00:00
func startPaychCreatorReceiverMiner(ctx context.Context, t *testing.T, paymentCreator *kit.TestFullNode, paymentReceiver *kit.TestFullNode, blocktime time.Duration) (address.Address, address.Address) {
var miner kit.TestMiner
opts := kit.ThroughRPC()
kit.NewEnsemble(t, kit.MockProofs()).
FullNode(paymentCreator, opts).
FullNode(paymentReceiver, opts).
2021-06-22 14:48:07 +00:00
Miner(&miner, paymentCreator, kit.WithAllSubsystems()).
Start().
InterconnectAll().
BeginMining(blocktime)
// Send some funds to the second node
receiverAddr, err := paymentReceiver.WalletDefaultAddress(ctx)
require.NoError(t, err)
2021-06-18 18:45:29 +00:00
kit.SendFunds(ctx, t, paymentCreator, receiverAddr, abi.NewTokenAmount(1e18))
// Get the first node's address
creatorAddr, err := paymentCreator.WalletDefaultAddress(ctx)
require.NoError(t, err)
return creatorAddr, receiverAddr
}