Wallet Management

export class WalletManager {
  private keystore: Keystore
  private password: string

  constructor(password: string, keystoreDir?: string) {
    this.keystore = new Keystore(keystoreDir)
    this.password = password
  }

  // Create, import, list, and manage wallets
  async createWallet(name: string, tags: string[] = []): Promise<WalletInfo>
  async createDerivedWallet(name: string, mnemonic: string, derivationIndex: number): Promise<WalletInfo>
  async importWallet(name: string, secretKey: Uint8Array): Promise<WalletInfo>
  async getKeypair(walletId: string): Promise<Keypair>
  async getBalances(walletId: string): Promise<WalletBalance>
}

async encrypt(
  keypair: Keypair,
  password: string,
  metadata: { id: string; name: string; derivationIndex?: number; tags?: string[] },
): Promise<EncryptedKeystore> {
  const salt = crypto.randomBytes(32)
  const iv = crypto.randomBytes(16)

  // Derive encryption key from password using scrypt
  const derivedKey = await this.deriveKey(password, salt)

  // Encrypt the secret key
  const cipher = crypto.createCipheriv('aes-256-gcm', derivedKey, iv)
  const secretKeyBuffer = Buffer.from(keypair.secretKey)
  const encrypted = Buffer.concat([
    cipher.update(secretKeyBuffer),
    cipher.final(),
  ])
  const authTag = cipher.getAuthTag()

  const keystore: EncryptedKeystore = {
    version: 1,
    id: metadata.id,
    address: keypair.publicKey.toBase58(),
    crypto: {
      cipher: 'aes-256-gcm',
      ciphertext: encrypted.toString('hex'),
      cipherparams: {
        iv: iv.toString('hex'),
        tag: authTag.toString('hex'),
      },
      kdf: 'scrypt',
      kdfparams: {
        n: 16384,  // CPU/memory cost
        r: 8,
        p: 1,
        dklen: 32, // 256-bit key
        salt: salt.toString('hex'),
      },
    },
    metadata: { name: metadata.name, createdAt: new Date().toISOString(), ... },
  }

  // Save to disk as JSON
  fs.writeFileSync(`data/keystores/${metadata.id}.json`, JSON.stringify(keystore, null, 2))
  return keystore
}

{
  "version": 1,
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "address": "HN7cABqYkE2qYkE2qYkE2qYkE2qYkE2qYkE2qYkE2",
  "crypto": {
    "cipher": "aes-256-gcm",
    "ciphertext": "a3f7b2c9d8e1f0...",
    "cipherparams": {
      "iv": "1a2b3c4d5e6f7g8h",
      "tag": "9i8h7g6f5e4d3c2b"
    },
    "kdf": "scrypt",
    "kdfparams": {
      "n": 16384,
      "r": 8,
      "p": 1,
      "dklen": 32,
      "salt": "f8e7d6c5b4a39281"
    }
  },
  "metadata": {
    "name": "my-agent-wallet",
    "createdAt": "2026-03-03T12:00:00.000Z",
    "derivationIndex": 0,
    "tags": ["agent", "trading"]
  }
}

const SCRYPT_PARAMS = {
  n: 16384,              // CPU/memory cost (2^14 iterations)
  r: 8,                  // Block size
  p: 1,                  // Parallelization factor
  dklen: 32,             // Derived key length (256 bits)
  maxmem: 64 * 1024 * 1024, // 64MB memory limit
}

export interface WalletInfo {
  id: string
  name: string
  publicKey: string
  createdAt: string
  derivationIndex?: number
  tags: string[]
}

export interface WalletBalance {
  sol: number
  tokens: TokenBalance[]
}

export interface TokenBalance {
  mint: string
  symbol?: string
  balance: number
  decimals: number
  uiBalance: number
}

export interface EncryptedKeystore {
  version: 1
  id: string
  address: string
  crypto: {
    cipher: 'aes-256-gcm'
    ciphertext: string
    cipherparams: { iv: string; tag: string }
    kdf: 'scrypt'
    kdfparams: {
      n: number
      r: number
      p: number
      dklen: number
      salt: string
    }
  }
  metadata: {
    name: string
    createdAt: string
    derivationIndex?: number
    tags: string[]
  }
}