fixup! multi: lwk configuration support for Liquid swaps

clightning/lwkconfig_test.go

@@ -0,0 +1,59 @@
+package clightning_test
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/elementsproject/peerswap/clightning"
+	"github.com/stretchr/testify/assert"
+	"github.com/vulpemventures/go-elements/network"
+)
+
+func TestLWKConfigFromToml(t *testing.T) {
+	t.Parallel()
+	t.Run("valid toml config", func(t *testing.T) {
+		t.Parallel()
+		file := `
+		[LWK]
+		signername="signername"
+		walletname="walletname"
+		lwkendpoint="http://localhost:32110"
+		network="liquid"
+		liquidswaps=true
+		`
+		filePath := filepath.Join(t.TempDir(), "peerswap.conf")
+		assert.NoError(t, os.WriteFile(filePath, []byte(file), fs.ModePerm))
+		got, err := clightning.LWKConfigFromToml(filePath)
+		if err != nil {
+			t.Errorf("LWKConfigFromToml() error = %v", err)
+			return
+		}
+		assert.Equal(t, got.GetChain(), &network.Liquid)
+		assert.Equal(t, got.GetElectrumEndpoint(), "blockstream.info:995")
+		assert.Equal(t, got.GetLWKEndpoint(), "http://localhost:32110")
+		assert.Equal(t, got.GetLiquidSwaps(), true)
+		assert.Equal(t, got.GetNetwork(), "liquid")
+	})
+	t.Run("default toml config", func(t *testing.T) {
+		t.Parallel()
+		file := `
+		[LWK]
+		network="liquid-testnet"
+		liquidswaps=true
+		`
+		filePath := filepath.Join(t.TempDir(), "peerswap.conf")
+		assert.NoError(t, os.WriteFile(filePath, []byte(file), fs.ModePerm))
+		got, err := clightning.LWKConfigFromToml(filePath)
+		if err != nil {
+			t.Errorf("LWKConfigFromToml() error = %v", err)
+			return
+		}
+		assert.Equal(t, got.GetChain(), &network.Testnet)
+		assert.Equal(t, got.GetElectrumEndpoint(), "blockstream.info:465")
+		assert.Equal(t, got.GetLWKEndpoint(), "http://localhost:32111")
+		assert.Equal(t, got.GetLiquidSwaps(), true)
+		assert.Equal(t, got.GetNetwork(), "liquid-testnet")
+	})
+}

cmd/peerswaplnd/config.go

@@ -186,7 +186,7 @@ func LWKFromIniFileConfig(filePath string) (*lwk.Conf, error) {
 			return nil, err
 		}
 	}
-	flagParser := flags.NewParser(cfg, flags.Default)
+	flagParser := flags.NewParser(cfg, flags.Default|flags.IgnoreUnknown)
 	if _, err := flagParser.Parse(); err != nil {
 		return nil, err
 	}

cmd/peerswaplnd/config_test.go

@@ -0,0 +1,59 @@
+package peerswaplnd_test
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/elementsproject/peerswap/cmd/peerswaplnd"
+	"github.com/stretchr/testify/assert"
+	"github.com/vulpemventures/go-elements/network"
+)
+
+func TestLWKFromIniFileConfig(t *testing.T) {
+	t.Parallel()
+	t.Run("valid ini config", func(t *testing.T) {
+		t.Parallel()
+		file := `
+		lwk.signername=signername
+		lwk.walletname=walletname
+		lwk.lwkendpoint=http://localhost:32110
+		lwk.network=liquid
+		lwk.liquidswaps=true
+		`
+
+		filePath := filepath.Join(t.TempDir(), "peerswap.conf")
+		assert.NoError(t, os.WriteFile(filePath, []byte(file), fs.ModePerm))
+		got, err := peerswaplnd.LWKFromIniFileConfig(filePath)
+		if err != nil {
+			t.Errorf("LWKConfigFromToml() error = %v", err)
+			return
+		}
+		assert.Equal(t, got.GetChain(), &network.Liquid)
+		assert.Equal(t, got.GetElectrumEndpoint(), "blockstream.info:995")
+		assert.Equal(t, got.GetLWKEndpoint(), "http://localhost:32110")
+		assert.Equal(t, got.GetLiquidSwaps(), true)
+		assert.Equal(t, got.GetNetwork(), "liquid")
+	})
+	t.Run("default ini config", func(t *testing.T) {
+		t.Parallel()
+		file := `
+		lwk.network=liquid-testnet
+		lwk.liquidswaps=true
+		`
+
+		filePath := filepath.Join(t.TempDir(), "peerswap.conf")
+		assert.NoError(t, os.WriteFile(filePath, []byte(file), fs.ModePerm))
+		got, err := peerswaplnd.LWKFromIniFileConfig(filePath)
+		if err != nil {
+			t.Errorf("LWKConfigFromToml() error = %v", err)
+			return
+		}
+		assert.Equal(t, got.GetChain(), &network.Testnet)
+		assert.Equal(t, got.GetElectrumEndpoint(), "blockstream.info:465")
+		assert.Equal(t, got.GetLWKEndpoint(), "http://localhost:32111")
+		assert.Equal(t, got.GetLiquidSwaps(), true)
+		assert.Equal(t, got.GetNetwork(), "liquid-testnet")
+	})
+}

lwk/conf_builder.go

@@ -4,7 +4,7 @@ type confBuilder struct {
 	Conf
 }
 
-func NewConfBuilder(network lwkNetwork) *confBuilder {
+func NewConfBuilder(network LwkNetwork) *confBuilder {
 	return &confBuilder{
 		Conf: Conf{
 			network: network,
@@ -17,10 +17,10 @@ func (b *confBuilder) DefaultConf() (*confBuilder, error) {
 		lwkEndpoint, electrumEndpoint string
 	)
 	switch b.network {
-	case networkTestnet:
+	case NetworkTestnet:
 		lwkEndpoint = "http://localhost:32111"
 		electrumEndpoint = "blockstream.info:465"
-	case networkRegtest:
+	case NetworkRegtest:
 		lwkEndpoint = "http://localhost:32112"
 		electrumEndpoint = "http://localhost:60401"
 	default:

lwk/conf_builder_test.go

@@ -0,0 +1,86 @@
+package lwk_test
+
+import (
+	"testing"
+
+	"github.com/elementsproject/peerswap/lwk"
+	"github.com/vulpemventures/go-elements/network"
+)
+
+func Test_confBuilder_DefaultConf(t *testing.T) {
+	t.Parallel()
+	b, err := lwk.NewConfBuilder(lwk.NetworkTestnet).DefaultConf()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	c, err := b.Build()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.GetChain() != &network.Testnet {
+		t.Fatalf("unexpected chain: %v", c.GetChain())
+	}
+	if c.GetElectrumEndpoint() != "blockstream.info:465" {
+		t.Fatalf("unexpected electrum endpoint: %v", c.GetElectrumEndpoint())
+	}
+	if c.GetLWKEndpoint() != "http://localhost:32111" {
+		t.Fatalf("unexpected lwk endpoint: %v", c.GetLWKEndpoint())
+	}
+	if c.GetLiquidSwaps() != true {
+		t.Fatalf("unexpected liquid swaps: %v", c.GetLiquidSwaps())
+	}
+	if c.GetNetwork() != lwk.NetworkTestnet.String() {
+		t.Fatalf("unexpected network: %v", c.GetNetwork())
+	}
+	if c.GetSignerName() != "defaultPeerswapSigner" {
+		t.Fatalf("unexpected signer name: %v", c.GetSignerName())
+	}
+	if c.GetWalletName() != "defaultPeerswapWallet" {
+		t.Fatalf("unexpected wallet name: %v", c.GetWalletName())
+	}
+}
+
+func Test_confBuilder_SetConfs(t *testing.T) {
+	t.Parallel()
+	t.Run("OK if it called with valid arguments", func(t *testing.T) {
+		b, err := lwk.NewConfBuilder(lwk.NetworkTestnet).DefaultConf()
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		c, err := b.SetSignerName("testSigner").SetWalletName("testSigner").Build()
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if c.GetChain() != &network.Testnet {
+			t.Fatalf("unexpected chain: %v", c.GetChain())
+		}
+		if c.GetElectrumEndpoint() != "blockstream.info:465" {
+			t.Fatalf("unexpected electrum endpoint: %v", c.GetElectrumEndpoint())
+		}
+		if c.GetLWKEndpoint() != "http://localhost:32111" {
+			t.Fatalf("unexpected lwk endpoint: %v", c.GetLWKEndpoint())
+		}
+		if c.GetLiquidSwaps() != true {
+			t.Fatalf("unexpected liquid swaps: %v", c.GetLiquidSwaps())
+		}
+		if c.GetNetwork() != lwk.NetworkTestnet.String() {
+			t.Fatalf("unexpected network: %v", c.GetNetwork())
+		}
+		if c.GetSignerName() != "testSigner" {
+			t.Fatalf("unexpected signer name: %v", c.GetSignerName())
+		}
+		if c.GetWalletName() != "testSigner" {
+			t.Fatalf("unexpected wallet name: %v", c.GetWalletName())
+		}
+	})
+	t.Run("Error if it called with empty signer name", func(t *testing.T) {
+		b, err := lwk.NewConfBuilder(lwk.NetworkTestnet).DefaultConf()
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		_, err = b.SetSignerName("").Build()
+		if err == nil {
+			t.Fatalf("expected error, got nil")
+		}
+	})
+}

lwk/config.go

@@ -12,7 +12,7 @@ type Conf struct {
 	walletName       confname
 	lwkEndpoint      confurl
 	electrumEndpoint confurl
-	network          lwkNetwork
+	network          LwkNetwork
 	liquidSwaps      bool
 }
 
@@ -42,45 +42,45 @@ func (c *Conf) GetLiquidSwaps() bool {
 
 func (c *Conf) GetChain() *network.Network {
 	switch c.network {
-	case networkMainnet:
+	case NetworkMainnet:
 		return &network.Liquid
-	case networkRegtest:
+	case NetworkRegtest:
 		return &network.Regtest
-	case networkTestnet:
+	case NetworkTestnet:
 		return &network.Testnet
 	default:
 		return &network.Testnet
 	}
 }
 
-type lwkNetwork string
+type LwkNetwork string
 
 const (
-	networkMainnet lwkNetwork = "liquid"
-	networkTestnet lwkNetwork = "liquid-testnet"
-	networkRegtest lwkNetwork = "liquid-regtest"
+	NetworkMainnet LwkNetwork = "liquid"
+	NetworkTestnet LwkNetwork = "liquid-testnet"
+	NetworkRegtest LwkNetwork = "liquid-regtest"
 )
 
-func (n lwkNetwork) String() string {
+func (n LwkNetwork) String() string {
 	return string(n)
 }
 
-func NewlwkNetwork(lekNetwork string) (lwkNetwork, error) {
+func NewlwkNetwork(lekNetwork string) (LwkNetwork, error) {
 	switch lekNetwork {
 	case "liquid":
-		return networkMainnet, nil
+		return NetworkMainnet, nil
 	case "liquid-testnet":
-		return networkTestnet, nil
+		return NetworkTestnet, nil
 	case "liquid-regtest":
-		return networkRegtest, nil
+		return NetworkRegtest, nil
 	default:
 		return "", errors.New("invalid network")
 	}
 }
 
-func (n lwkNetwork) validate() error {
+func (n LwkNetwork) validate() error {
 	switch n {
-	case networkMainnet, networkTestnet, networkRegtest:
+	case NetworkMainnet, NetworkTestnet, NetworkRegtest:
 		return nil
 	default:
 		return errors.New("invalid network")
@@ -109,7 +109,7 @@ type confurl struct {
 }
 
 func NewConfURL(endpoint string) (*confurl, error) {
-	u, err := url.Parse(endpoint)
+	u, err := url.ParseRequestURI(endpoint)
 	if err != nil {
 		return nil, err
 	}

lwk/config_test.go

@@ -0,0 +1,78 @@
+package lwk_test
+
+import (
+	"testing"
+
+	"github.com/elementsproject/peerswap/lwk"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewlwkNetwork(t *testing.T) {
+	t.Parallel()
+	tests := map[string]struct {
+		network string
+		want    lwk.LwkNetwork
+	}{
+		"mainnet": {
+			network: "liquid",
+			want:    lwk.NetworkMainnet,
+		},
+		"testnet": {
+			network: "liquid-testnet",
+			want:    lwk.NetworkTestnet,
+		},
+		"regtest": {
+			network: "liquid-regtest",
+			want:    lwk.NetworkRegtest,
+		},
+	}
+	for name, tt := range tests {
+		tt := tt
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			got, err := lwk.NewlwkNetwork(tt.network)
+			if err != nil {
+				t.Errorf("NewlwkNetwork() error = %v", err)
+			}
+			if got != tt.want {
+				t.Errorf("NewlwkNetwork() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewConfURL(t *testing.T) {
+	t.Parallel()
+	tests := map[string]struct {
+		endpoint string
+		want     string
+		wantErr  bool
+	}{
+		"valid url": {
+			endpoint: "http://localhost:32111",
+			want:     "http://localhost:32111",
+		},
+		"without protocol": {
+			endpoint: "localhost:32111",
+			want:     "localhost:32111",
+		},
+		"invalid url": {
+			endpoint: "invalid url",
+			wantErr:  true,
+		},
+	}
+	for name, tt := range tests {
+		tt := tt
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			got, err := lwk.NewConfURL(tt.endpoint)
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			if got.String() != tt.want {
+				t.Errorf("NewConfURL() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}