Wallets and Signers

/**
 * Basic wallet implementation for private key management and transaction signing
 */
class Wallet extends BaseWallet {
  constructor(key: string | SigningKey, provider?: Provider);
  
  readonly address: string;
  readonly privateKey: string;
  readonly publicKey: string;
  
  // Account creation
  static createRandom(provider?: Provider): Wallet;
  static fromPhrase(phrase: string, password?: string, provider?: Provider): Wallet;
  
  // Provider connection
  connect(provider: Provider): Wallet;
  
  // Signing operations
  signMessage(message: string | Uint8Array): Promise<string>;
  signTransaction(transaction: TransactionRequest): Promise<string>;
  signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): Promise<string>;
  
  // Transaction operations
  sendTransaction(transaction: TransactionRequest): Promise<TransactionResponse>;
  
  // Encryption/decryption
  encrypt(password: string, options?: EncryptOptions): Promise<string>;
  static fromEncryptedJson(json: string, password: string, progress?: ProgressCallback): Promise<Wallet>;
  static fromEncryptedJsonSync(json: string, password: string): Wallet;
}

import { Wallet, JsonRpcProvider } from "ethers";

// Create wallet from private key
const wallet = new Wallet("0x...", provider);

// Create random wallet
const randomWallet = Wallet.createRandom();

// Create from mnemonic phrase
const mnemonicWallet = Wallet.fromPhrase("word1 word2 ... word12");

// Sign a message
const signature = await wallet.signMessage("Hello, Ethereum!");

// Send transaction
const tx = await wallet.sendTransaction({
  to: "0x...",
  value: ethers.parseEther("1.0")
});

/**
 * HD wallet supporting BIP-32/BIP-44 hierarchical key derivation
 */
class HDNodeWallet extends BaseWallet {
  readonly address: string;
  readonly privateKey: string;
  readonly publicKey: string;
  readonly chainCode: string;
  readonly path?: string;
  readonly index: number;
  readonly depth: number;
  
  // Wallet creation
  static fromPhrase(phrase: string, password?: string, path?: string, provider?: Provider): HDNodeWallet;
  static fromSeed(seed: BytesLike): HDNodeWallet;
  static fromExtendedKey(extendedKey: string): HDNodeWallet;
  
  // Key derivation
  derivePath(path: string): HDNodeWallet;
  deriveChild(index: number): HDNodeWallet;
  
  // Extended keys
  get extendedKey(): string;
  get neuter(): HDNodeWallet;
}

/**
 * Read-only version of HDNodeWallet for public key operations only
 */
class HDNodeVoidWallet extends VoidSigner {
  readonly address: string;
  readonly publicKey: string;
  readonly chainCode: string;
  readonly path?: string;
  readonly index: number;
  readonly depth: number;
  
  derivePath(path: string): HDNodeVoidWallet;
  deriveChild(index: number): HDNodeVoidWallet;
}

import { HDNodeWallet } from "ethers";

// Create HD wallet from mnemonic
const hdWallet = HDNodeWallet.fromPhrase("word1 word2 ... word24");

// Derive specific account
const account0 = hdWallet.derivePath("m/44'/60'/0'/0/0");
const account1 = hdWallet.derivePath("m/44'/60'/0'/0/1");

// Derive child wallets
const childWallet = hdWallet.deriveChild(0);

/**
 * BIP-39 mnemonic phrase management for secure seed generation
 */
class Mnemonic {
  readonly phrase: string;
  readonly password: string;
  readonly wordlist: Wordlist;
  readonly entropy: string;
  
  constructor(guard: any, entropy: string, phrase: string, password?: string, wordlist?: Wordlist);
  
  // Mnemonic creation
  static fromPhrase(phrase: string, password?: string, wordlist?: Wordlist): Mnemonic;
  static fromEntropy(entropy: BytesLike, password?: string, wordlist?: Wordlist): Mnemonic;
  
  // Seed computation
  computeSeed(): string;
  
  // Validation
  static isValidMnemonic(phrase: string, wordlist?: Wordlist): boolean;
  
  // Entropy generation
  static entropyToMnemonic(entropy: BytesLike, wordlist?: Wordlist): string;
  static mnemonicToEntropy(mnemonic: string, wordlist?: Wordlist): string;
}

/**
 * Abstract base class for all wordlists
 */
abstract class Wordlist {
  readonly locale: string;
  
  constructor(locale: string);
  
  // Split phrase into words (language-specific)
  split(phrase: string): Array<string>;
  
  // Join words into phrase (language-specific)
  join(words: Array<string>): string;
  
  // Get word at specific index (0-2047)
  abstract getWord(index: number): string;
  
  // Get index of specific word
  abstract getWordIndex(word: string): number;
}

/**
 * English wordlist implementation (recommended for compatibility)
 */
class LangEn extends Wordlist {
  static wordlist(): Wordlist;
}

/**
 * Optimized wordlist implementation using compression
 */
class WordlistOwl extends Wordlist {
  constructor(locale: string, data: string, checksum: string);
}

/**
 * Alternative optimized wordlist implementation
 */
class WordlistOwlA extends Wordlist {
  constructor(locale: string, data: string, checksum: string);
}

/**
 * Registry of available wordlists by ISO 639-1 language codes
 */
const wordlists: Record<string, Wordlist>;

import { 
  wordlists, 
  LangEn, 
  Mnemonic, 
  HDNodeWallet 
} from "ethers";

// Use English wordlist (default and recommended)
const englishWordlist = wordlists.en;
const phrase = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";

// Validate mnemonic with specific wordlist
const isValid = Mnemonic.isValidMnemonic(phrase, englishWordlist);

// Create mnemonic with specific wordlist
const mnemonic = Mnemonic.fromPhrase(phrase, "password", englishWordlist);

// Generate entropy and convert to mnemonic
const entropy = "0x133755ff"; // 128 bits minimum
const mnemonicPhrase = Mnemonic.entropyToMnemonic(entropy, wordlists.en);

// Use different languages
const frenchWordlist = wordlists.fr;
const spanishWordlist = wordlists.es;

// Create wallet with specific wordlist  
const hdWallet = HDNodeWallet.fromPhrase(phrase, "password", "m/44'/60'/0'/0/0", frenchWordlist);

// Working with wordlist directly
const wordAtIndex = englishWordlist.getWord(0); // "abandon"
const indexOfWord = englishWordlist.getWordIndex("abandon"); // 0

// Split and join operations (language-specific)
const words = englishWordlist.split("word1 word2 word3");
const rejoined = englishWordlist.join(words);

/**
 * Check if a string is a valid keystore JSON format
 */
function isKeystoreJson(json: string): boolean;

/**
 * Decrypt a keystore JSON synchronously
 */
function decryptKeystoreJsonSync(json: string, password: string): KeystoreAccount;

/**
 * Decrypt a keystore JSON asynchronously with progress callback
 */
function decryptKeystoreJson(json: string, password: string, progress?: ProgressCallback): Promise<KeystoreAccount>;

/**
 * Encrypt a keystore JSON synchronously
 */
function encryptKeystoreJsonSync(account: KeystoreAccount, password: string, options?: EncryptOptions): string;

/**
 * Encrypt a keystore JSON asynchronously with progress callback
 */
function encryptKeystoreJson(account: KeystoreAccount, password: string, options?: EncryptOptions, progress?: ProgressCallback): Promise<string>;

interface KeystoreAccount {
  address: string;
  privateKey: string;
}

interface EncryptOptions {
  iv?: BytesLike;
  entropy?: BytesLike;
  client?: string;
  salt?: BytesLike;
  uuid?: string;
  scrypt?: {
    N?: number;
    r?: number;
    p?: number;
  };
}

/**
 * Check if a string is a valid crowdsale JSON format
 */
function isCrowdsaleJson(json: string): boolean;

/**
 * Decrypt a crowdsale JSON wallet
 */
function decryptCrowdsaleJson(json: string, password: string): CrowdsaleAccount;

interface CrowdsaleAccount {
  address: string;
  privateKey: string;
}

/**
 * ECDSA signing key for cryptographic operations
 */
class SigningKey {
  constructor(privateKey: BytesLike);
  
  readonly privateKey: string;
  readonly publicKey: string;
  readonly compressedPublicKey: string;
  readonly address: string;
  
  // Signing operations
  sign(digest: BytesLike): Signature;
  
  // Key computation
  computeSharedSecret(otherKey: BytesLike): string;
  
  // Static utilities
  static computePublicKey(key: BytesLike, compressed?: boolean): string;
  static recoverPublicKey(digest: BytesLike, signature: SignatureLike): string;
  static addPoints(p0: BytesLike, p1: BytesLike, compressed?: boolean): string;
}

/**
 * Signer that delegates operations to a JSON-RPC provider
 */
class JsonRpcSigner extends AbstractSigner {
  constructor(provider: JsonRpcApiProvider, address: string);
  
  // Account information
  getAddress(): Promise<string>;
  
  // Signing operations
  signMessage(message: string | Uint8Array): Promise<string>;
  signTransaction(transaction: TransactionRequest): Promise<string>;
  signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): Promise<string>;
  
  // Transaction operations
  sendTransaction(transaction: TransactionRequest): Promise<TransactionResponse>;
  
  // Provider connection
  connect(provider: Provider): JsonRpcSigner;
}

/**
 * Read-only signer for operations without private key access
 */
class VoidSigner extends AbstractSigner {
  constructor(address: string, provider?: Provider);
  
  readonly address: string;
  
  // Account information
  getAddress(): Promise<string>;
  
  // Signing operations (will throw)
  signMessage(message: string | Uint8Array): Promise<string>;
  signTransaction(transaction: TransactionRequest): Promise<string>;
  signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): Promise<string>;
  
  // Provider connection
  connect(provider: Provider): VoidSigner;
}

/**
 * Default BIP-44 derivation path for Ethereum accounts
 */
const defaultPath: string; // "m/44'/60'/0'/0/0"

/**
 * Get BIP-44 derivation path for a specific account index
 */
function getAccountPath(index: number): string;

/**
 * Get indexed account path (alias for getAccountPath)
 */
function getIndexedAccountPath(index: number): string;

import { defaultPath, getAccountPath, HDNodeWallet } from "ethers";

console.log(defaultPath); // "m/44'/60'/0'/0/0"
console.log(getAccountPath(5)); // "m/44'/60'/0'/0/5"

// Use with HD wallet
const hdWallet = HDNodeWallet.fromPhrase("word1 word2 ... word12");
const account5 = hdWallet.derivePath(getAccountPath(5));

type ProgressCallback = (percent: number) => void;

interface TypedDataDomain {
  name?: string;
  version?: string;
  chainId?: BigNumberish;
  verifyingContract?: string;
  salt?: BytesLike;
}

interface TypedDataField {
  name: string;
  type: string;
}