constructor(mnemonic: string, passphrase?: string, config: WalletConfig)

interface WalletConfig {
  networkId: number;        // Network ID (1 = Mainnet, 2 = Stokenet)
  applicationName?: string; // Application name for identification
  accountIndex?: number;    // Account index to use (default: 0)
}

const wallet = new RadixMnemonicWallet(
  "abandon abandon abandon ... art",
  "", // Empty passphrase for Radix Wallet compatibility
  {
    networkId: 2, // Stokenet
    applicationName: "MyApp",
    accountIndex: 0
  }
);

const wallet = RadixMnemonicWallet.generateRandom({
  networkId: 2, // Stokenet
  applicationName: "RadixAgentKit"
});

console.log("Address:", wallet.getAddress());
console.log("Mnemonic:", wallet.getMnemonic());

const wallet = await RadixMnemonicWallet.generateRandomAsync({
  networkId: 2,
  applicationName: "MyApp"
});

// Address is properly derived and ready
console.log("Address:", wallet.getAddress()); // account_tdx_2_...

const wallet = RadixMnemonicWallet.fromMnemonic(
  process.env.RADIX_MNEMONIC!,
  { networkId: 2 }
);

const wallet = await RadixMnemonicWallet.fromMnemonicAsync(
  process.env.RADIX_MNEMONIC!,
  { networkId: 2 }
);

const address = wallet.getAddress();
console.log(address); // account_tdx_2_1c8atrq...

const publicKey = wallet.getPublicKey();
console.log(publicKey); // 32-byte hex string

const privateKey = wallet.getPrivateKeyHex();
// ⚠️ Keep this secure! Never log or expose

const mnemonic = wallet.getMnemonic();
// ⚠️ Sensitive information - backup securely
console.log("Backup:", mnemonic);

const data = new TextEncoder().encode("Hello Radix");
const signature = await wallet.sign(data);
console.log("Signature:", signature);

const signedTransaction = await wallet.signTransaction(transactionIntent);

const signature = await wallet.signWithAccount(1, data);

interface DerivedAccount {
  index: number;
  privateKey: string;
  publicKey: string;
  address: string;
  derivationPath: string;
}

const account = wallet.getCurrentAccount();
console.log("Current account:", account.index);
console.log("Address:", account.address);

// Switch to account 1
const newAccount = await wallet.switchToAccount(1);
console.log("Switched to:", newAccount.address);

// Now all operations use account 1
const balance = await gateway.getAccountBalances(wallet.getAddress());

const account1 = await wallet.deriveAccount(1);
const account2 = await wallet.deriveAccount(2);

console.log("Account 1:", account1.address);
console.log("Account 2:", account2.address);

// Derive accounts 0-4
const accounts = await wallet.deriveMultipleAccounts(0, 5);

accounts.forEach((account, i) => {
  console.log(`Account ${i}:`, account.address);
});

const accounts = wallet.getAllAccounts();
console.log(`${accounts.length} accounts derived`);

const canSign = wallet.canSignFor("account_tdx_2_1c8atrq...");
if (canSign) {
  console.log("Wallet controls this address");
}

interface NetworkInfo {
  networkId: number;
  applicationName: string;
  currentAccountIndex: number;
  totalAccounts: number;
}

const info = wallet.getNetworkInfo();
console.log("Network:", info.networkId === 2 ? "Stokenet" : "Mainnet");
console.log("Current account:", info.currentAccountIndex);
console.log("Total accounts:", info.totalAccounts);

export interface PublicWalletInfo {
  networkId: number;
  applicationName: string;
  accounts: Array\<{
    index: number;
    address: string;
    publicKey: string;
    derivationPath: string;
  }>;
}

const publicInfo = wallet.exportPublicInfo();
console.log("Wallet info:", JSON.stringify(publicInfo, null, 2));

// Useful when you need to ensure address is fully derived
await wallet.waitForProperAddress();
const address = wallet.getAddress(); // Now guaranteed to be real address

const isValid = RadixMnemonicWallet.validateMnemonic(userMnemonic);
if (!isValid) {
  throw new Error("Invalid mnemonic phrase");
}

const mnemonic = RadixMnemonicWallet.generateMnemonic();
console.log("New mnemonic:", mnemonic);

const strength = RadixMnemonicWallet.getMnemonicStrength(mnemonic);
console.log("Strength:", strength); // 256 for 24 words

const wallet = RadixWalletFactory.createNew({
  networkId: 2,
  applicationName: "MyApp"
});

const wallet = RadixWalletFactory.importFromMnemonic(
  userMnemonic,
  { networkId: 2 }
);

// Uses RADIX_MNEMONIC environment variable
const wallet = RadixWalletFactory.fromEnvironment(undefined, {
  networkId: 2
});

// Or specify custom environment variable
const wallet = RadixWalletFactory.fromEnvironment("MY_WALLET_MNEMONIC", {
  networkId: 2
});

import { RadixMnemonicWallet } from "radix-agent-kit";

// Create new wallet
const wallet = RadixMnemonicWallet.generateRandom({
  networkId: 2, // Stokenet
  applicationName: "MyRadixApp"
});

console.log("Address:", wallet.getAddress());
console.log("Mnemonic:", wallet.getMnemonic()); // Backup securely!

// From mnemonic phrase
const wallet = RadixMnemonicWallet.fromMnemonic(
  "abandon abandon abandon ... art",
  { networkId: 2 }
);

// From environment
const wallet = RadixWalletFactory.fromEnvironment("RADIX_MNEMONIC", {
  networkId: 2
});

// Derive multiple accounts
const accounts = await wallet.deriveMultipleAccounts(0, 3);

// Use different accounts for different purposes
await wallet.switchToAccount(0); // Main account
const mainAddress = wallet.getAddress();

await wallet.switchToAccount(1); // Trading account  
const tradingAddress = wallet.getAddress();

await wallet.switchToAccount(2); // Savings account
const savingsAddress = wallet.getAddress();

import { RadixAgent, RadixNetwork } from "radix-agent-kit";

// Create wallet
const wallet = await RadixMnemonicWallet.generateRandomAsync({
  networkId: 2
});

// Use with agent
const agent = new RadixAgent({
  networkId: RadixNetwork.Stokenet,
  openaiApiKey: process.env.OPENAI_API_KEY,
  wallet: wallet
});

await agent.run("What's my balance?");

try {
  const wallet = RadixMnemonicWallet.fromMnemonic(userInput, config);
  const address = wallet.getAddress();
} catch (error) {
  if (error.message.includes("Invalid mnemonic")) {
    console.error("Please provide a valid 24-word mnemonic");
  } else if (error.message.includes("24-word mnemonic")) {
    console.error("Radix Agent Kit requires 24-word mnemonic phrases");
  } else {
    console.error("Wallet creation failed:", error.message);
  }
}

import { RadixGatewayClient } from "radix-agent-kit";

const gateway = new RadixGatewayClient({ networkId: 2 });
const balances = await gateway.getAccountBalances(wallet.getAddress());

import { RadixTransactionBuilder } from "radix-agent-kit";

const builder = new RadixTransactionBuilder({ networkId: 2 });
const manifest = builder.createTransferManifest({
  fromAccount: wallet.getAddress(),
  toAccount: targetAddress,
  resourceAddress: "resource_tdx_2_1tknxxxxxxxxxradixdxrdxxxxxxxxx009923554798xxxxxxxxxdxrdxt",
  amount: "100"
});

const signed = await builder.signAndSubmitTransaction(manifest, wallet);