fix: static files loading

keystore/keystore.go

@@ -26,8 +26,6 @@ const (
 	KDFScrypt KDFFunction = "scrypt"
 	KDFPBKDF2 KDFFunction = "pbkdf2"
 
-	DefaultWordListPath = "../word_lists"
-
 	DerivationPathBN254 = "m/254/60/0/0"
 )
 
@@ -495,7 +493,7 @@ func NewKeyPair(
 	language mnemonic.Language,
 ) (*KeyPair, error) {
 	// Get the mnemonic
-	pkMnemonic, err := mnemonic.GetMnemonic(language, DefaultWordListPath, nil)
+	pkMnemonic, err := mnemonic.GetMnemonic(language, nil)
 	if err != nil {
 		return nil, err
 	}

mnemonic/mnemonic.go

@@ -1,14 +1,11 @@
 package mnemonic
 
 import (
-	"bufio"
 	"crypto/rand"
 	"crypto/sha256"
 	"errors"
 	"fmt"
 	"math/big"
-	"os"
-	"path/filepath"
 	"slices"
 	"strings"
 
@@ -39,37 +36,12 @@ const (
 //
 // Parameters:
 //   - language (string): The language of the wordlist.
-//   - path (string): The path to the directory containing the wordlist file.
 //
 // Returns:
 //   - []string: A slice of words from the wordlist.
 //   - error: An error object if the wordlist file cannot be read.
-func getWordList(language Language, path string) ([]string, error) {
-	cleanLanguageFileName := filepath.Clean(fmt.Sprintf("%s.txt", language))
-
-	// Get the wordlist path
-	path = wordlists.GetWordListFolderPath()
-
-	// Append the path to the wordlist folder and the language file
-	filePath := filepath.Join(path, cleanLanguageFileName)
-
-	cleanFilePath := filepath.Clean(filePath)
-	file, err := os.Open(cleanFilePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open wordlist file: %v", err)
-	}
-	defer file.Close()
-
-	var wordList []string
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		word := strings.TrimSpace(scanner.Text())
-		wordList = append(wordList, word)
-	}
-	if err := scanner.Err(); err != nil {
-		return nil, fmt.Errorf("error reading wordlist: %v", err)
-	}
-	return wordList, nil
+func getWordList(language Language) ([]string, error) {
+	return wordlists.GetWordList(string(language))
 }
 
 // indexToWord returns the corresponding word for the given index in the word list.
@@ -143,12 +115,11 @@ func GetSeed(mnemonic, password string) ([]byte, error) {
 //
 // Parameters:
 //   - mnemonic (string): The mnemonic phrase.
-//   - wordsPath (string): The path to the directory containing the wordlist files.
 //
 // Returns:
 //   - []Language: A slice of detected languages.
 //   - error: An error object if the language determination fails.
-func determineMnemonicLanguage(mnemonic, wordsPath string) ([]Language, error) {
+func determineMnemonicLanguage(mnemonic string) ([]Language, error) {
 	languages := []Language{
 		English,
 		Italian,
@@ -162,7 +133,7 @@ func determineMnemonicLanguage(mnemonic, wordsPath string) ([]Language, error) {
 	wordLanguageMap := make(map[string]Language)
 
 	for _, lang := range languages {
-		wordList, err := getWordList(lang, wordsPath)
+		wordList, err := getWordList(lang)
 		if err != nil {
 			return nil, fmt.Errorf("failed to get wordlist for language %s: %v", lang, err)
 		}
@@ -268,22 +239,21 @@ func reconstructFromWordIndices(wordList []string, wordIndices []int) string {
 //
 // Parameters:
 //   - mnemonic (string): The abbreviated mnemonic phrase.
-//   - wordsPath (string): The path to the directory containing the wordlist files.
 //
 // Returns:
 //   - string: The reconstructed mnemonic.
 //   - error: An error object if the reconstruction fails.
-func ReconstructMnemonic(mnemonic, wordsPath string) (string, error) {
+func ReconstructMnemonic(mnemonic string) (string, error) {
 	// Determine the language of the mnemonic
-	languages, err := determineMnemonicLanguage(mnemonic, wordsPath)
+	languages, err := determineMnemonicLanguage(mnemonic)
 	if err != nil {
 		return "", err
 	}
 
 	var reconstructedMnemonic string
 	for _, language := range languages {
 		// Get the abbreviated word list and the full word list for the language
-		wordList, err := getWordList(language, wordsPath)
+		wordList, err := getWordList(language)
 		if err != nil {
 			return "", err
 		}
@@ -326,7 +296,7 @@ func ReconstructMnemonic(mnemonic, wordsPath string) (string, error) {
 		entropyBytes := entropy.FillBytes(make([]byte, checksumLength*4))
 
 		// Get the full word list for the language
-		fullWordList, err := getWordList(language, wordsPath)
+		fullWordList, err := getWordList(language)
 		if err != nil {
 			return "", err
 		}
@@ -354,13 +324,12 @@ func ReconstructMnemonic(mnemonic, wordsPath string) (string, error) {
 //
 // Parameters:
 //   - language (string): The language of the wordlist.
-//   - wordsPath (string): The path to the directory containing the wordlist files.
 //   - entropy ([]byte): The entropy bytes. If nil, random entropy will be generated.
 //
 // Returns:
 //   - string: The generated mnemonic phrase.
 //   - error: An error object if the mnemonic generation fails.
-func GetMnemonic(language Language, wordsPath string, entropy []byte) (string, error) {
+func GetMnemonic(language Language, entropy []byte) (string, error) {
 	// Generate random entropy if not provided
 	if entropy == nil {
 		entropy = make([]byte, 32) // 256 bits
@@ -382,7 +351,7 @@ func GetMnemonic(language Language, wordsPath string, entropy []byte) (string, e
 	entropyBits.Or(entropyBits, checksum)
 
 	// Load the word list for the specified language
-	wordList, err := getWordList(language, wordsPath)
+	wordList, err := getWordList(language)
 	if err != nil {
 		return "", fmt.Errorf("failed to load word list: %v", err)
 	}

mnemonic/mnemonic_test.go

@@ -13,7 +13,6 @@ import (
 )
 
 var (
-	wordListsPath              = filepath.Join(os.Getenv("PWD"), "..", "word_lists")
 	testVectorMnemonicFilePath = filepath.Join(os.Getenv("PWD"), "..", "tests_vectors", "mnemonic.json")
 	testVectorsMnemonic        map[Language][][4]string
 )
@@ -46,7 +45,7 @@ func TestBip39(t *testing.T) {
 				}
 
 				// Test the mnemonic generation from entropy
-				mnemonic, err := GetMnemonic(language, wordListsPath, testEntropy)
+				mnemonic, err := GetMnemonic(language, testEntropy)
 				if err != nil {
 					t.Fatalf("Failed to generate mnemonic: %v", err)
 				}
@@ -73,7 +72,7 @@ func TestReconstructMnemonic(t *testing.T) {
 			mnemonic := testMnemonic[1] // Extract the mnemonic from the test vector
 
 			t.Run(fmt.Sprintf("Testing mnemonic: %s", mnemonic), func(t *testing.T) {
-				reconstructedMnemonic, err := ReconstructMnemonic(mnemonic, wordListsPath)
+				reconstructedMnemonic, err := ReconstructMnemonic(mnemonic)
 				if err != nil {
 					t.Fatalf("Failed to reconstruct mnemonic: %v", err)
 				}
@@ -102,7 +101,7 @@ func TestReconstructAbbreviatedMnemonic(t *testing.T) {
 	for _, languageTestVectors := range testVectorsMnemonic {
 		for _, testMnemonic := range languageTestVectors {
 			abbreviatedMnemonic := abbreviateMnemonic(testMnemonic[1])
-			result, err := ReconstructMnemonic(abbreviatedMnemonic, wordListsPath)
+			result, err := ReconstructMnemonic(abbreviatedMnemonic)
 			assert.NoError(t, err)
 			if result == "" {
 				t.Errorf("Failed to reconstruct mnemonic: %s", abbreviatedMnemonic)
@@ -116,7 +115,7 @@ func TestGetWord(t *testing.T) {
 	language := English
 
 	// Get the word list for the specified language
-	wordList, err := getWordList(language, wordListsPath)
+	wordList, err := getWordList(language)
 	if err != nil {
 		t.Fatalf("Failed to get word list for language %s: %v", language, err)
 	}

wordlists/wordlists.go

@@ -1,17 +1,20 @@
 package wordlists
 
 import (
+	"embed"
 	"fmt"
-	"path/filepath"
-	"runtime"
+	"strings"
 )
 
-func GetWordListFolderPath() string {
-	_, filename, _, ok := runtime.Caller(0)
-	if !ok {
-		fmt.Println("Unable to get current file path")
-		return ""
-	}
+//go:embed all:files/*
+var staticFiles embed.FS
 
-	return filepath.Dir(filename)
+func GetWordList(language string) ([]string, error) {
+	data, err := staticFiles.ReadFile("files/" + fmt.Sprintf("%s.txt", language))
+	if err != nil {
+		return nil, err
+	}
+	content := string(data)
+	wordList := strings.Split(content, "\n")
+	return wordList, nil
 }