Generate Mnemonics using GoLang Programming Language

Hi Guys! Welcome to this Guide. This is the code I wrote in Golang with the assistance of Grok AI to generate valid, secure mnemonics for the Ethereum, EVM compatible chains like BSC, Polygon, Base, Arbitrum, and so on.

package main

import (
	"fmt"
	"log"
	"time"

	"github.com/btcsuite/btcd/btcutil/hdkeychain"
	"github.com/btcsuite/btcd/chaincfg"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/tyler-smith/go-bip39"
	"slices"
)

func main(){
    doIty()
}

func generateMnemonic() (string, error) {
    // Generate 128-bit entropy for a 12-word mnemonic (use 256 for 24 words)
    //entropy, err := bip39.NewEntropy(128)

    const wordCount = 24

    jk := []int{12, 15, 18, 21, 24}

    ks := 0

    if slices.Contains(jk, wordCount) {
            ks = 1
    }

    if ks != 1 {
        log.Fatalf("WordCount have to be any of: %d, %d, %d, %d, %d", 12, 15, 18, 21, 24)
    }

    const bitsEntropy = 32 * (wordCount / 3)

	entropy, err := bip39.NewEntropy(bitsEntropy) //256
    if err != nil {
        return "", err
    }
    mnemonic, err := bip39.NewMnemonic(entropy)
    if err != nil {
        return "", err
    }
    return mnemonic, nil
}

func mnemonicToPrivateKey(mnemonic string) (string, error) {
    // Generate seed from mnemonic (no passphrase for simplicity)
    seed := bip39.NewSeed(mnemonic, "")

    // Create master key from seed
    masterKey, err := hdkeychain.NewMaster(seed, &chaincfg.MainNetParams)
    if err != nil {
        return "", err
    }

    // Ethereum derivation path: m/44'/60'/0'/0/0
    path := []uint32{
        44 | hdkeychain.HardenedKeyStart,  // Purpose (44')
        60 | hdkeychain.HardenedKeyStart,  // Coin type (60' for Ethereum)
        0 | hdkeychain.HardenedKeyStart,   // Account (0')
        0,                                 // Change (0)
        0,                                 // Index (0)
    }

    // Derive the key using the path
    key := masterKey
    for _, n := range path {
        key, err = key.Derive(n)
        if err != nil {
            return "", err
        }
    }

    // Get the private key
    privKey, err := key.ECPrivKey()
    if err != nil {
        return "", err
    }

    // Convert to hex string
    privKeyBytes := privKey.Serialize()
    privKeyHex := fmt.Sprintf("%x", privKeyBytes)

    return privKeyHex, nil
}

func privateKeyToEthereumAddress(privateKeyHex string) (string, error) {
    // Decode hex string to bytes
    privKeyBytes, err := crypto.HexToECDSA(privateKeyHex)
    if err != nil {
        return "", err
    }

    // Derive public key and Ethereum address
    publicKey := privKeyBytes.PublicKey
    address := crypto.PubkeyToAddress(publicKey).Hex()

    return address, nil
}

func doIty(){
	// Generate mnemonic
    mnemonic, err := generateMnemonic()
    if err != nil {
        log.Fatalf("Error generating mnemonic: %v", err)
    }

    // Generate private key from mnemonic
    privateKey, err := mnemonicToPrivateKey(mnemonic)
    if err != nil {
        log.Fatalf("Error generating private key: %v", err)
    }

    // Generate Ethereum address from private key
    address, err := privateKeyToEthereumAddress(privateKey)
    if err != nil {
        log.Fatalf("Error generating address: %v", err)
    }    

    // Verify mnemonic validity
    isValid := bip39.IsMnemonicValid(mnemonic)

	if(isValid){
		fmt.Println(mnemonic)
		fmt.Println(privateKey)
		fmt.Println(address)
		fmt.Println()

		vv := time.Second * 15 / 10

		time.Sleep(vv)

		doIty()
	
    }else{
        time.Sleep(time.Second)
        doIty()
    }

}

// go mod init lamala (start new project or module on go)
// go run . or go run anoda.go(specific go file)
// go build
// go build -o custom_app.exe (windows)
// go build -o custom_app (linux)
// go build -ldflags="-s -w" -o custom_appy.exe //for production, strip debug flags, only essential, reduce file size
// go build -ldflags="-s -w" -o "password_gen.exe"

Install dependencies and run the program, it will generate secure valid mnemonics. “go run mnems.go”. Example run:

this perfect own fix error label into correct vote choose junior weird
8ec834f53145578816e0375b11efee06a051d3a14cd8f09f8540517a0795f232
0x6916b3DF6E6526ef16C0e57BF0d72CE5f2718DE1

goddess put radio walk below actual brave ostrich void buyer topic element
c05fcac2d48f426c9aaa7cf1d69fe740fbb6e875a892357a525f64dd342cd690
0xa1e77d992018600a66d9B6FBAc7FB5eaAF722dD4

unaware atom love usage aerobic lonely aspect chair spring obtain custom walnut
0f2856fa759c3cdb2c51392c6054ed6e799fe1debe9a0a5d25d80b065b9da466
0x06a1bc5B0E170c4946E739E44bB6a067E12Fc9cE

view scan wolf wear tube beauty panic lottery accuse aisle pig increase celery moon control nephew wrap grit daring what chest bread waste lottery
eeb4e0b14d8bc5bcc33e28c4e632d49a5848d034d3ef24528bb58e5ee68d2fea
0x5758350671Fd975721cD918967445ec81Ce54665

caught cart arrange palm decide midnight afraid load jump wisdom deny cupboard depth phrase feature sword kite permit over cabin club relief inhale trend
4fdf3273b21d2416f2a65e0b1c1c845ecad1a755a7ff9953e85e687172da0bd3
0x436c3bD93D30Af305BF10ebA7133d42b59251560

bamboo never grocery jungle before upset people glue clay salt provide solar runway cute when unit horse fall plug erase pride quarter kind engine
6a0168b3159b70620b1e22c8945ecfb4e365455bee1853ca6c4557e80c656ab4
0x1b727a9B045D018d7623bedd451CB1dA693f15C4

face sight sing appear friend mind club gold minute settle satisfy journey model cluster space violin alien element decide save artist post cattle proof
f14b1c2d264b71b65acd41fe9e046587ea19754daa7216f30e44b3d007f87d45
0x9C745649B4597b83D7f30C9C53E8F37d20D08126