Get Blockchain Configuration

interface ChainConfig {
  linea: NetworkConfig;
  ethereum: NetworkConfig;
  solana: SolanaConfig;
}

interface NetworkConfig {
  chain_id: number;
  usdc_address: string;
  usdt_address: string;
  spender_address: string;
}

interface SolanaConfig {
  usdc_mint: string;
  usdt_mint: string;
  delegate_address: string;
}

async function loadBlockchainConfig(accessToken: string): Promise<ChainConfig> {
  const response = await fetch('https://dev.api.baanx.com/v1/delegation/chain/config', {
    method: 'GET',
    headers: {
      'x-client-key': 'YOUR_PUBLIC_KEY',
      'Authorization': `Bearer ${accessToken}`
    }
  });

  if (!response.ok) {
    throw new Error(`Failed to load config: ${response.status}`);
  }

  return await response.json();
}

// Usage in delegation workflow
async function initiateDelegation(
  network: 'linea' | 'ethereum' | 'solana',
  currency: 'usdc' | 'usdt',
  amount: string
) {
  // Step 0: Get blockchain configuration
  const config = await loadBlockchainConfig(userAccessToken);

  if (network === 'solana') {
    // Use Solana configuration
    const mintAddress = currency === 'usdc' 
      ? config.solana.usdc_mint 
      : config.solana.usdt_mint;
    const delegateAddress = config.solana.delegate_address;
    
    // Proceed with Solana delegation logic...
  } else {
    // Use EVM configuration
    const networkConfig = config[network];
    const tokenAddress = currency === 'usdc' 
      ? networkConfig.usdc_address 
      : networkConfig.usdt_address;
    const spenderAddress = networkConfig.spender_address;
    const chainId = networkConfig.chain_id;
    
    // Proceed with EVM delegation logic...
    await approveTokenSpending(tokenAddress, spenderAddress, amount, chainId);
  }
}

async function approveTokenSpending(
  tokenAddress: string,
  spenderAddress: string,
  amount: string,
  chainId: number
) {
  // Verify user's wallet is on correct network
  const currentNetwork = await provider.getNetwork();
  if (currentNetwork.chainId !== chainId) {
    throw new Error(`Please switch to chain ID ${chainId}`);
  }

  // Create approval transaction using configuration
  const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, signer);
  const tx = await tokenContract.approve(
    spenderAddress,
    ethers.utils.parseUnits(amount, 6) // Assuming 6 decimals for USDC/USDT
  );

  return await tx.wait();
}

class DelegationManager {
  private config: ChainConfig | null = null;

  async initialize(accessToken: string) {
    this.config = await loadBlockchainConfig(accessToken);
  }

  getNetworkOptions() {
    if (!this.config) throw new Error('Configuration not loaded');
    
    return [
      {
        name: 'Linea',
        chainId: this.config.linea.chain_id,
        currencies: ['USDC', 'USDT']
      },
      {
        name: 'Ethereum',
        chainId: this.config.ethereum.chain_id,
        currencies: ['USDC', 'USDT']
      },
      {
        name: 'Solana',
        currencies: ['USDC', 'USDT']
      }
    ];
  }

  getContractAddress(network: string, currency: string): string {
    if (!this.config) throw new Error('Configuration not loaded');
    
    const networkConfig = this.config[network as keyof ChainConfig];
    if (!networkConfig) throw new Error(`Unsupported network: ${network}`);
    
    if (network === 'solana') {
      const solanaConfig = networkConfig as SolanaConfig;
      return currency === 'usdc' ? solanaConfig.usdc_mint : solanaConfig.usdt_mint;
    } else {
      const evmConfig = networkConfig as NetworkConfig;
      return currency === 'usdc' ? evmConfig.usdc_address : evmConfig.usdt_address;
    }
  }
}

function validateChainConfig(config) {
  const requiredFields = {
    linea: ['chain_id', 'usdc_address', 'usdt_address', 'spender_address'],
    ethereum: ['chain_id', 'usdc_address', 'usdt_address', 'spender_address'],
    solana: ['usdc_mint', 'usdt_mint', 'delegate_address']
  };

  for (const [network, fields] of Object.entries(requiredFields)) {
    if (!config[network]) {
      throw new Error(`Missing ${network} configuration`);
    }

    for (const field of fields) {
      if (!config[network][field]) {
        throw new Error(`Missing ${field} in ${network} configuration`);
      }
    }
  }

  // Validate address formats
  const evmAddressRegex = /^0x[a-fA-F0-9]{40}$/;
  if (!evmAddressRegex.test(config.linea.usdc_address)) {
    throw new Error('Invalid Linea USDC address format');
  }

  return true;
}