interface RadixWallet {
  getAddress(): string;
  getPublicKey(): string;
  getPrivateKeyHex(): string;
  sign(data: Uint8Array): Promise\<string>;
  signTransaction(transactionIntent: any): Promise\<any>;
}

const address = wallet.getAddress();
console.log("Wallet address:", address);
// Example: account_tdx_2_1c8atrq...

const publicKey = wallet.getPublicKey();
console.log("Public key:", publicKey);
// Example: 32-byte hex string

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

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

const signedTransaction = await wallet.signTransaction(transactionIntent);

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

const wallet: RadixWallet = RadixMnemonicWallet.generateRandom({
  networkId: 2
});

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

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

const wallet: RadixWallet = new VaultWallet({
  networkId: 2,
  vaultPath: "./secure-vault",
  encryptionKey: process.env.VAULT_KEY
});

console.log("Secure address:", wallet.getAddress());

interface HardwareWallet extends RadixWallet {
  isConnected(): boolean;
  connect(): Promise\<void>;
  disconnect(): Promise\<void>;
  getDeviceInfo(): Promise\<DeviceInfo>;
}

interface SignableTransactionIntent {
  intentHash: string;
  payloadBytes: Uint8Array;
}

interface SignedTransaction {
  intentHash: string;
  signature: string;
  publicKey: string;
  compiledTransaction: string;
  intentPayload: Uint8Array;
  signatures: string[];
}

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

function createWallet(type: 'mnemonic' | 'vault', config: any): RadixWallet {
  switch (type) {
    case 'mnemonic':
      return RadixMnemonicWallet.fromMnemonic(config.mnemonic, config);
    case 'vault':
      return new VaultWallet(config);
    default:
      throw new Error(`Unknown wallet type: ${type}`);
  }
}

const wallet = createWallet('mnemonic', {
  mnemonic: process.env.RADIX_MNEMONIC,
  networkId: 2
});

async function performOperation(wallet: RadixWallet): Promise\<string> {
  // Works with any wallet implementation
  const address = wallet.getAddress();
  const data = new TextEncoder().encode(`Operation for ${address}`);
  const signature = await wallet.sign(data);
  
  return signature;
}

// Works with any wallet type
const mnemonicWallet = RadixMnemonicWallet.generateRandom({ networkId: 2 });
const vaultWallet = new VaultWallet({ networkId: 2, vaultPath: "./vault" });

const sig1 = await performOperation(mnemonicWallet);
const sig2 = await performOperation(vaultWallet);

function validateWallet(wallet: RadixWallet): boolean {
  try {
    // Check if wallet has valid address
    const address = wallet.getAddress();
    if (!address || !address.startsWith('account_')) {
      return false;
    }
    
    // Check if wallet has public key
    const publicKey = wallet.getPublicKey();
    if (!publicKey || publicKey.length !== 64) { // 32 bytes = 64 hex chars
      return false;
    }
    
    return true;
  } catch (error) {
    return false;
  }
}

const isValid = validateWallet(wallet);
console.log("Wallet valid:", isValid);

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

// Any RadixWallet implementation works
const agent = new RadixAgent({
  networkId: RadixNetwork.Stokenet,
  openaiApiKey: process.env.OPENAI_API_KEY,
  wallet: wallet // RadixWallet interface
});

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

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

const builder = new RadixTransactionBuilder({
  networkId: RadixNetwork.Stokenet
});

// Create transaction manifest
const manifest = builder.createTransferManifest(
  wallet.getAddress(),
  targetAddress,
  builder.getXRDResourceAddress(),
  "100"
);

// Sign with any wallet implementation
const privateKey = RadixTransactionBuilder.createPrivateKeyFromHex(
  wallet.getPrivateKeyHex()
);

const result = await builder.buildCustomManifestTransaction(
  manifest,
  privateKey,
  currentEpoch
);

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

const gateway = new RadixGatewayClient({
  networkId: RadixNetwork.Stokenet
});

// Query wallet balance
const balances = await gateway.getAccountBalances(wallet.getAddress());

// Sign and submit transaction
const signedTx = await wallet.signTransaction(transactionIntent);
const result = await gateway.submitTransaction(signedTx);

class CustomWallet implements RadixWallet {
  private address: string;
  private publicKey: string;
  private privateKey: string;
  
  constructor(config: CustomWalletConfig) {
    // Initialize wallet
    this.address = config.address;
    this.publicKey = config.publicKey;
    this.privateKey = config.privateKey;
  }
  
  getAddress(): string {
    return this.address;
  }
  
  getPublicKey(): string {
    return this.publicKey;
  }
  
  getPrivateKeyHex(): string {
    return this.privateKey;
  }
  
  async sign(data: Uint8Array): Promise\<string> {
    // Implement signing logic
    // Use Ed25519 signing with private key
    return "signature_hex";
  }
  
  async signTransaction(transactionIntent: any): Promise\<any> {
    // Implement transaction signing
    const signature = await this.sign(transactionIntent.payloadBytes);
    return {
      intentHash: transactionIntent.intentHash,
      signature: signature,
      publicKey: this.publicKey
    };
  }
}

// Use custom wallet
const customWallet: RadixWallet = new CustomWallet({
  address: "account_tdx_2_1c8atrq...",
  publicKey: "public_key_hex",
  privateKey: "private_key_hex"
});

async function safeWalletOperation(wallet: RadixWallet): Promise\<string | null> {
  try {
    const data = new TextEncoder().encode("test");
    const signature = await wallet.sign(data);
    return signature;
  } catch (error) {
    if (error.message.includes('private key')) {
      console.error("Private key error - wallet may be locked");
    } else if (error.message.includes('network')) {
      console.error("Network error - check connection");
    } else if (error.message.includes('hardware')) {
      console.error("Hardware wallet error - check device");
    } else {
      console.error("Wallet operation failed:", error.message);
    }
    return null;
  }
}