feat: rln subcommands

.gitignore

@@ -64,6 +64,12 @@ Icon
 # Nix
 result
 
+# Solidity files
+waku/v2/protocol/rln/contracts/*.abi
+waku/v2/protocol/rln/contracts/*.sol
+waku/v2/protocol/rln/contracts/*.bin
+
+
 # Thumbnails
 ._*
 

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "waku/v2/protocol/rln/contracts/rln-contract"]
+	path = waku/v2/protocol/rln/contracts/rln-contract
+	url = [email protected]:vacp2p/rln-contract.git

cmd/waku/flags_rln.go

@@ -64,15 +64,6 @@ func rlnFlags() []cli.Flag {
 			Usage:       "the index of credentials to use",
 			Destination: &options.RLNRelay.CredentialsIndex,
 		},
-		// TODO: this is a good candidate option for subcommands
-		// TODO: consider accepting a private key file and passwd
-		&cli.GenericFlag{
-			Name:  "rln-relay-eth-account-private-key",
-			Usage: "Ethereum  account private key used for registering in member contract",
-			Value: &wcli.PrivateKeyValue{
-				Value: &options.RLNRelay.ETHPrivateKey,
-			},
-		},
 		&cli.StringFlag{
 			Name:        "rln-relay-eth-client-address",
 			Usage:       "Ethereum testnet client address",

cmd/waku/main.go

@@ -6,6 +6,7 @@ import (
 	cli "github.com/urfave/cli/v2"
 	"github.com/urfave/cli/v2/altsrc"
 	"github.com/waku-org/go-waku/cmd/waku/keygen"
+	"github.com/waku-org/go-waku/cmd/waku/rlngenerate"
 	"github.com/waku-org/go-waku/waku/v2/node"
 )
 
@@ -114,6 +115,7 @@ func main() {
 		},
 		Commands: []*cli.Command{
 			&keygen.Command,
+			&rlngenerate.Command,
 		},
 	}
 

cmd/waku/node_rln.go

@@ -4,7 +4,6 @@
 package main
 
 import (
-	"crypto/ecdsa"
 	"errors"
 
 	"github.com/waku-org/go-waku/waku/v2/node"
@@ -20,12 +19,6 @@ func checkForRLN(logger *zap.Logger, options NodeOptions, nodeOpts *[]node.WakuN
 		if !options.RLNRelay.Dynamic {
 			*nodeOpts = append(*nodeOpts, node.WithStaticRLNRelay(options.RLNRelay.PubsubTopic, options.RLNRelay.ContentTopic, rln.MembershipIndex(options.RLNRelay.MembershipGroupIndex), nil))
 		} else {
-
-			var ethPrivKey *ecdsa.PrivateKey
-			if options.RLNRelay.ETHPrivateKey != nil {
-				ethPrivKey = options.RLNRelay.ETHPrivateKey
-			}
-
 			// TODO: too many parameters in this function
 			// consider passing a config struct instead
 			*nodeOpts = append(*nodeOpts, node.WithDynamicRLNRelay(
@@ -39,8 +32,6 @@ func checkForRLN(logger *zap.Logger, options NodeOptions, nodeOpts *[]node.WakuN
 				rln.MembershipIndex(options.RLNRelay.MembershipGroupIndex),
 				nil,
 				options.RLNRelay.ETHClientAddress,
-				ethPrivKey,
-				nil,
 			))
 		}
 	}

cmd/waku/options.go

@@ -43,7 +43,6 @@ type RLNRelayOptions struct {
 	PubsubTopic               string
 	ContentTopic              string
 	Dynamic                   bool
-	ETHPrivateKey             *ecdsa.PrivateKey
 	ETHClientAddress          string
 	MembershipContractAddress common.Address
 }

cmd/waku/rlngenerate/command_no_rln.go

@@ -0,0 +1,19 @@
+//go:build !gowaku_rln
+// +build !gowaku_rln
+
+package rlngenerate
+
+import (
+	"errors"
+
+	cli "github.com/urfave/cli/v2"
+)
+
+// Command generates a key file used to generate the node's peerID, encrypted with an optional password
+var Command = cli.Command{
+	Name:  "generate-rln-credentials",
+	Usage: "Generate credentials for usage with RLN",
+	Action: func(cCtx *cli.Context) error {
+		return errors.New("not available. Execute `make RLN=true` to add RLN support to go-waku")
+	},
+}

cmd/waku/rlngenerate/command_rln.go

@@ -0,0 +1,142 @@
+//go:build gowaku_rln
+// +build gowaku_rln
+
+package rlngenerate
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/ethclient"
+	cli "github.com/urfave/cli/v2"
+	"github.com/waku-org/go-waku/logging"
+	"github.com/waku-org/go-waku/waku/v2/protocol/rln/contracts"
+	"github.com/waku-org/go-waku/waku/v2/protocol/rln/group_manager/dynamic"
+	"github.com/waku-org/go-waku/waku/v2/protocol/rln/keystore"
+	"github.com/waku-org/go-waku/waku/v2/utils"
+	"github.com/waku-org/go-zerokit-rln/rln"
+	"go.uber.org/zap"
+)
+
+var options Options
+var logger = utils.Logger().Named("rln-credentials")
+
+// Command generates a key file used to generate the node's peerID, encrypted with an optional password
+var Command = cli.Command{
+	Name:  "generate-rln-credentials",
+	Usage: "Generate credentials for usage with RLN",
+	Action: func(cCtx *cli.Context) error {
+		err := verifyFlags()
+		if err != nil {
+			logger.Error("validating option flags", zap.Error(err))
+			return cli.Exit(err, 1)
+		}
+
+		err = execute(context.Background())
+		if err != nil {
+			logger.Error("registering RLN credentials", zap.Error(err))
+			return cli.Exit(err, 1)
+		}
+
+		return nil
+	},
+	Flags: flags,
+}
+
+func verifyFlags() error {
+	if options.CredentialsPath == "" {
+		logger.Warn("keystore: no credentials path set, using default path", zap.String("path", keystore.RLN_CREDENTIALS_FILENAME))
+		options.CredentialsPath = keystore.RLN_CREDENTIALS_FILENAME
+	}
+
+	if options.CredentialsPassword == "" {
+		logger.Warn("keystore: no credentials password set, using default password", zap.String("password", keystore.RLN_CREDENTIALS_PASSWORD))
+		options.CredentialsPassword = keystore.RLN_CREDENTIALS_PASSWORD
+	}
+
+	if options.ETHPrivateKey == nil {
+		return errors.New("a private key must be specified")
+	}
+
+	return nil
+}
+
+func execute(ctx context.Context) error {
+	ethClient, err := ethclient.Dial(options.ETHClientAddress)
+	if err != nil {
+		return err
+	}
+
+	rlnInstance, err := rln.NewRLN()
+	if err != nil {
+		return err
+	}
+
+	chainID, err := ethClient.ChainID(ctx)
+	if err != nil {
+		return err
+	}
+
+	rlnContract, err := contracts.NewRLN(options.MembershipContractAddress, ethClient)
+	if err != nil {
+		return err
+	}
+
+	// prepare rln membership key pair
+	logger.Info("generating rln credential")
+	identityCredential, err := rlnInstance.MembershipKeyGen()
+	if err != nil {
+		return err
+	}
+
+	// register the rln-relay peer to the membership contract
+	membershipIndex, err := register(ctx, ethClient, rlnContract, identityCredential.IDCommitment, chainID)
+	if err != nil {
+		return err
+	}
+
+	// TODO: clean private key from memory
+
+	err = persistCredentials(identityCredential, membershipIndex, chainID)
+	if err != nil {
+		return err
+	}
+
+	if logger.Level() == zap.DebugLevel {
+		logger.Info("registered credentials into the membership contract",
+			logging.HexString("IDCommitment", identityCredential.IDCommitment[:]),
+			logging.HexString("IDNullifier", identityCredential.IDNullifier[:]),
+			logging.HexString("IDSecretHash", identityCredential.IDSecretHash[:]),
+			logging.HexString("IDTrapDoor", identityCredential.IDTrapdoor[:]),
+			zap.Uint("index", membershipIndex),
+		)
+	} else {
+		logger.Info("registered credentials into the membership contract", logging.HexString("idCommitment", identityCredential.IDCommitment[:]), zap.Uint("index", membershipIndex))
+	}
+
+	ethClient.Close()
+
+	return nil
+}
+
+func persistCredentials(identityCredential *rln.IdentityCredential, membershipIndex rln.MembershipIndex, chainID *big.Int) error {
+	membershipGroup := keystore.MembershipGroup{
+		TreeIndex: membershipIndex,
+		MembershipContract: keystore.MembershipContract{
+			ChainId: fmt.Sprintf("0x%X", chainID.Int64()),
+			Address: options.MembershipContractAddress.String(),
+		},
+	}
+
+	membershipGroupIndex, err := keystore.AddMembershipCredentials(options.CredentialsPath, identityCredential, membershipGroup, options.CredentialsPassword, dynamic.RLNAppInfo, keystore.DefaultSeparator)
+	if err != nil {
+		return fmt.Errorf("failed to persist credentials: %w", err)
+	}
+
+	// TODO: obtain keystore index?
+	logger.Info("persisted credentials succesfully", zap.Uint("membershipGroupIndex", membershipGroupIndex))
+
+	return nil
+}

cmd/waku/rlngenerate/flags.go

@@ -0,0 +1,75 @@
+//go:build gowaku_rln
+// +build gowaku_rln
+
+package rlngenerate
+
+import (
+	cli "github.com/urfave/cli/v2"
+	wcli "github.com/waku-org/go-waku/waku/cliutils"
+	"github.com/waku-org/go-waku/waku/v2/protocol/rln/keystore"
+)
+
+var flags = []cli.Flag{
+	&cli.PathFlag{
+		Name:        "cred-path",
+		Usage:       "RLN relay membership credentials file",
+		Value:       keystore.RLN_CREDENTIALS_FILENAME,
+		Destination: &options.CredentialsPath,
+	},
+	&cli.StringFlag{
+		Name:        "cred-password",
+		Value:       keystore.RLN_CREDENTIALS_PASSWORD,
+		Usage:       "Password for encrypting RLN credentials",
+		Destination: &options.CredentialsPassword,
+	},
+	&cli.GenericFlag{
+		Name:  "eth-account-private-key",
+		Usage: "Ethereum  account private key used for registering in member contract",
+		Value: &wcli.PrivateKeyValue{
+			Value: &options.ETHPrivateKey,
+		},
+	},
+	&cli.StringFlag{
+		Name:        "eth-client-address",
+		Usage:       "Ethereum testnet client address",
+		Value:       "ws://localhost:8545",
+		Destination: &options.ETHClientAddress,
+	},
+	&cli.GenericFlag{
+		Name:  "eth-contract-address",
+		Usage: "Address of membership contract",
+		Value: &wcli.AddressValue{
+			Value: &options.MembershipContractAddress,
+		},
+	},
+	&cli.StringFlag{
+		Name:        "eth-nonce",
+		Value:       "",
+		Usage:       "Set an specific ETH transaction nonce. Leave empty to calculate the nonce automatically",
+		Destination: &options.ETHNonce,
+	},
+	&cli.Uint64Flag{
+		Name:        "eth-gas-limit",
+		Value:       0,
+		Usage:       "Gas limit to set for the transaction execution (0 = estimate)",
+		Destination: &options.ETHGasLimit,
+	},
+	&cli.StringFlag{
+		Name:        "eth-gas-price",
+		Value:       "",
+		Usage:       "Gas price  in wei to use for the transaction execution (empty = gas price oracle)",
+		Destination: &options.ETHGasPrice,
+	},
+	&cli.StringFlag{
+		Name:        "eth-gas-fee-cap",
+		Value:       "",
+		Usage:       "Gas fee cap in wei to use for the 1559 transaction execution (empty = gas price oracle)",
+		Destination: &options.ETHGasFeeCap,
+	},
+	&cli.StringFlag{
+		Name:        "eth-gas-tip-cap",
+		Value:       "",
+		Usage:       "Gas priority fee cap in wei to use for the 1559 transaction execution (empty = gas price oracle)",
+		Destination: &options.ETHGasTipCap,
+	},
+}

cmd/waku/rlngenerate/options.go

@@ -0,0 +1,21 @@
+package rlngenerate
+
+import (
+	"crypto/ecdsa"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// Options are settings used to create RLN credentials.
+type Options struct {
+	CredentialsPath           string
+	CredentialsPassword       string
+	ETHPrivateKey             *ecdsa.PrivateKey
+	ETHClientAddress          string
+	MembershipContractAddress common.Address
+	ETHGasLimit               uint64
+	ETHNonce                  string
+	ETHGasPrice               string
+	ETHGasFeeCap              string
+	ETHGasTipCap              string
+}