mirror of https://github.com/status-im/go-waku.git
124 lines
3.6 KiB
Go
124 lines
3.6 KiB
Go
//go:build gowaku_rln
|
|
// +build gowaku_rln
|
|
|
|
package waku
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/keystore"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/status-im/go-waku/waku/v2/node"
|
|
"github.com/status-im/go-zerokit-rln/rln"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
const RLN_CREDENTIALS_FILENAME = "rlnCredentials.txt"
|
|
|
|
func writeRLNMembershipCredentialsToFile(keyPair *rln.MembershipKeyPair, idx rln.MembershipIndex, contractAddress common.Address, path string, passwd []byte, overwrite bool) error {
|
|
if path == "" {
|
|
return nil // we dont want to use a credentials file
|
|
}
|
|
|
|
if keyPair == nil {
|
|
return nil // no credentials to store
|
|
}
|
|
|
|
path = filepath.Join(path, RLN_CREDENTIALS_FILENAME)
|
|
|
|
if err := checkForFileExistence(path, overwrite); err != nil {
|
|
return err
|
|
}
|
|
fmt.Println("AQUI 2")
|
|
fmt.Println(keyPair)
|
|
credentialsJSON, err := json.Marshal(node.MembershipCredentials{
|
|
Keypair: keyPair,
|
|
Index: idx,
|
|
Contract: contractAddress,
|
|
})
|
|
|
|
fmt.Println(string(credentialsJSON))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
encryptedCredentials, err := keystore.EncryptDataV3(credentialsJSON, passwd, keystore.StandardScryptN, keystore.StandardScryptP)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
output, err := json.Marshal(encryptedCredentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return ioutil.WriteFile(path, output, 0600)
|
|
}
|
|
|
|
func loadMembershipCredentialsFromFile(credentialsFilePath string, passwd string) (node.MembershipCredentials, error) {
|
|
src, err := ioutil.ReadFile(credentialsFilePath)
|
|
if err != nil {
|
|
return node.MembershipCredentials{}, err
|
|
}
|
|
|
|
var encryptedK keystore.CryptoJSON
|
|
err = json.Unmarshal(src, &encryptedK)
|
|
if err != nil {
|
|
return node.MembershipCredentials{}, err
|
|
}
|
|
|
|
credentialsBytes, err := keystore.DecryptDataV3(encryptedK, passwd)
|
|
if err != nil {
|
|
return node.MembershipCredentials{}, err
|
|
}
|
|
|
|
var credentials node.MembershipCredentials
|
|
err = json.Unmarshal(credentialsBytes, &credentials)
|
|
|
|
return credentials, err
|
|
}
|
|
|
|
func getMembershipCredentials(logger *zap.Logger, options Options) (fromFile bool, credentials node.MembershipCredentials, err error) {
|
|
if options.RLNRelay.CredentialsPath == "" { // Not using a file
|
|
return false, node.MembershipCredentials{
|
|
Contract: options.RLNRelay.MembershipContractAddress,
|
|
}, nil
|
|
}
|
|
|
|
credentialsFilePath := filepath.Join(options.RLNRelay.CredentialsPath, RLN_CREDENTIALS_FILENAME)
|
|
if _, err = os.Stat(credentialsFilePath); err == nil {
|
|
if credentials, err := loadMembershipCredentialsFromFile(credentialsFilePath, options.KeyPasswd); err != nil {
|
|
return false, node.MembershipCredentials{}, fmt.Errorf("could not read membership credentials file: %w", err)
|
|
} else {
|
|
logger.Info("loaded rln credentials", zap.String("filepath", credentialsFilePath))
|
|
if (bytes.Equal(credentials.Contract.Bytes(), common.Address{}.Bytes())) {
|
|
credentials.Contract = options.RLNRelay.MembershipContractAddress
|
|
}
|
|
return true, credentials, nil
|
|
}
|
|
}
|
|
|
|
var keypair *rln.MembershipKeyPair
|
|
if os.IsNotExist(err) {
|
|
if options.RLNRelay.IDKey != "" && options.RLNRelay.IDCommitment != "" {
|
|
keypair = new(rln.MembershipKeyPair)
|
|
copy((keypair.IDKey)[:], common.FromHex(options.RLNRelay.IDKey))
|
|
copy((keypair.IDCommitment)[:], common.FromHex(options.RLNRelay.IDCommitment))
|
|
}
|
|
|
|
return false, node.MembershipCredentials{
|
|
Keypair: keypair,
|
|
Index: uint(options.RLNRelay.MembershipIndex),
|
|
Contract: options.RLNRelay.MembershipContractAddress,
|
|
}, nil
|
|
|
|
}
|
|
|
|
return false, node.MembershipCredentials{}, fmt.Errorf("could not read membership credentials file: %w", err)
|
|
}
|