Seed Phrase Wallets

Seed phrase wallets derive cryptographic keys from 24-word BIP-39 mnemonics through hierarchical deterministic (HD) derivation. The same mnemonic always generates the same addresses and keys, following BIP-32/BIP-44 standards.

What They Are

Memorable word sequences that serve as master seeds for all cryptographic material. The SDK handles BIP-32/BIP-44 derivation internally—provide the mnemonic and account index, and it generates payment keys, staking keys, and addresses following Cardano's standard derivation paths.

When to Use

Development: Rapid prototyping with reproducible test addresses
Testing: Automated tests with known, predictable wallets
Demonstrations: Educational examples and tutorials
Team onboarding: Shared test credentials across developers

Why They Work

Mnemonics provide human-friendly backup and recovery. The same 24 words reconstruct all keys across any compliant wallet. Reproducibility simplifies test automation—the same mnemonic always generates the same addresses.

How to Secure

Never use in production with real funds. Anyone with the phrase controls the funds.

Store in environment variables
Use distinct mnemonics per environment (dev/staging/prod)
Never commit to version control
Keep testnet and mainnet mnemonics completely separate

Generate Mnemonic

Use the SDK to generate a cryptographically secure 24-word mnemonic:

import {  } from "@evolution-sdk/evolution";

// Generate 24-word mnemonic (256-bit entropy)
const  = ..();
.();
// Example output: "abandon abandon abandon ... art art art"

Basic Setup

import {  } from "@evolution-sdk/evolution";

// Create a signing-only client with seed wallet (no provider)
// Can sign transactions but cannot query blockchain or submit
const  = ({
  : "preprod",
  : {
    : "seed",
    : "fitness juice ankle box prepare gallery purse narrow miracle next soccer category analyst wait verb patch kit era hen clerk write skin trumpet attract",
    : 0  // First account (increment for more accounts)
  }
});

// Get address (wallet operations work without provider)
const  = await .();
.("Derived address:", );

// To query blockchain or submit, attach a provider:
// const fullClient = client.attachProvider({ type: "blockfrost", ... });

Configuration Options

interface SeedWalletConfig {
  type: "seed"
  mnemonic: string        // 24-word BIP-39 phrase (required)
  accountIndex?: number   // Account derivation index (default: 0)
}

Network Switching

Different networks use the same wallet configuration—just change the network parameter:

import {  } from "@evolution-sdk/evolution";

// Testnet client
const  = ({
  : "preprod",
  : {
    : "seed",
    : "fitness juice ankle box prepare gallery purse narrow miracle next soccer category analyst wait verb patch kit era hen clerk write skin trumpet attract",
    : 0
  }
});

// Mainnet client (use DIFFERENT mnemonic in production!)
const  = ({
  : "mainnet",
  : {
    : "seed",
    : ..!,  // Different mnemonic!
    : 0
  }
});

Environment Variables

# .env.local (NEVER commit this file)
WALLET_MNEMONIC="fitness juice ankle box prepare gallery purse narrow miracle next soccer category analyst wait verb patch kit era hen clerk write skin trumpet attract"
BLOCKFROST_PROJECT_ID="preprodYourProjectIdHere"

import {  } from "@evolution-sdk/evolution";

const  = ({
  : "preprod",
  : {
    : "seed",
    : ..!,  // From environment
    : 0
  }
});

Multiple Accounts

Generate independent wallets from the same mnemonic using different accountIndex values:

import {  } from "@evolution-sdk/evolution";

// Account 0 (default)
const  = ({
  : "preprod",
  : {
    : "seed",
    : ..!,
    : 0
  }
});

// Account 1 (different addresses, same mnemonic)
const  = ({
  : "preprod",
  : {
    : "seed",
    : ..!,
    : 1
  }
});

const  = await .();
const  = await .();
.("Different addresses:",  !== ); // true

Common Patterns

Development Testing

import {  } from "@evolution-sdk/evolution";

// Mock test runner functions for documentation
declare function (: string, : () => void): void;
declare function (: () => void): void;
declare function (: string, : () => void | <void>): void;
declare const : any;

// Mock environment variable
declare const : { : { ?: string } };

("Payment tests", () => {
  let : any;

  (() => {
     = ({
      : "preprod",
      : {
        : "seed",
        : ..!,
        : 0
      }
    });
  });

  ("should sign transaction", async () => {
    // Wallet client can sign but needs provider to build/submit
    // For full flow, attach provider: client.attachProvider(...)
    const  = await .address();
    ().toBeDefined();
  });
});

Security Reminders

Never commit mnemonics to Git. Never reuse testnet mnemonics on mainnet. Never use seed phrases in production with real funds. Never share production mnemonics.

Always use environment variables. Always keep separate mnemonics per environment. Always test on preprod or preview networks first before moving to mainnet.

Next Steps

Private Key Wallets - Production automation
API Wallets - User-facing applications
Security - Complete security guide

Seed Phrase Wallets

On this page