createPool.js

import StellarSdk from "@stellar/stellar-sdk";
import config from "../config.json" with { type: "json" };

const { 
  accounts: { issuer, distributor, buyer },
  network: { serverUrl, networkPassphrase },
  asset: { code: assetCode }
} = config;

const server = new StellarSdk.Horizon.Server(serverUrl);

/**
 * Create a new liquidity pool with custom parameters
 */
const createNewPool = async (poolConfig) => {
  try {
    const {
      assetA,
      assetB,
      feeBp = 30, // Default 0.3% fee
      initialAmountA,
      initialAmountB,
      accountType = "distributor",
      poolName = "Custom Pool"
    } = poolConfig;

    console.log(`🏊 Creating new pool: ${poolName}\n`);
    console.log(`📊 Assets: ${assetA} ↔ ${assetB}`);
    console.log(`💰 Fee: ${feeBp} basis points (${(feeBp / 100).toFixed(2)}%)`);
    console.log(`💧 Initial liquidity: ${initialAmountA} + ${initialAmountB}\n`);

    // Choose account
    const account = accountType === "buyer" ? buyer : distributor;
    const accountName = accountType === "buyer" ? "Buyer" : "Distributor";
    
    console.log(`👤 Using ${accountName} account: ${account.publicKey}`);

    // Load account
    const accountData = await server.loadAccount(account.publicKey);

    const txOptions = {
      fee: await server.fetchBaseFee(),
      networkPassphrase: networkPassphrase
    };

    // Create assets
    let stellarAssetA, stellarAssetB;
    
    if (assetA === "native" || assetA === "Test-π") {
      stellarAssetA = StellarSdk.Asset.native();
    } else {
      stellarAssetA = new StellarSdk.Asset(assetA, issuer.publicKey);
    }
    
    if (assetB === "native" || assetB === "Test-π") {
      stellarAssetB = StellarSdk.Asset.native();
    } else {
      stellarAssetB = new StellarSdk.Asset(assetB, issuer.publicKey);
    }

    // Check account balances
    const balanceA = accountData.balances.find(b => {
      if (assetA === "native" || assetA === "Test-π") {
        return b.asset_type === "native";
      } else {
        return b.asset_code === assetA && b.asset_issuer === issuer.publicKey;
      }
    });

    const balanceB = accountData.balances.find(b => {
      if (assetB === "native" || assetB === "Test-π") {
        return b.asset_type === "native";
      } else {
        return b.asset_code === assetB && b.asset_issuer === issuer.publicKey;
      }
    });

    console.log(`📊 Current ${accountName} balances:`);
    console.log(`   ${assetA}: ${balanceA?.balance || '0'}`);
    console.log(`   ${assetB}: ${balanceB?.balance || '0'}`);

    // Validate balances
    if (!balanceA || parseFloat(balanceA.balance) < parseFloat(initialAmountA)) {
      throw new Error(`Insufficient ${assetA} balance. Required: ${initialAmountA}, Available: ${balanceA?.balance || '0'}`);
    }

    if (!balanceB || parseFloat(balanceB.balance) < parseFloat(initialAmountB)) {
      throw new Error(`Insufficient ${assetB} balance. Required: ${initialAmountB}, Available: ${balanceB?.balance || '0'}`);
    }

    // Create liquidity pool asset with standard fee (30 basis points)
    console.log(`⚠️  Using standard fee: 30 basis points (0.3%)`);
    
    const liquidityPoolAsset = new StellarSdk.LiquidityPoolAsset(
      stellarAssetA,
      stellarAssetB,
      StellarSdk.LiquidityPoolFeeV18
    );

    const transactionBuilder = new StellarSdk.TransactionBuilder(accountData, txOptions);

    // Step 1: Establish trustline to the liquidity pool
    console.log("🔗 Step 1: Establishing trustline to liquidity pool...");
    transactionBuilder.addOperation(
      StellarSdk.Operation.changeTrust({
        asset: liquidityPoolAsset,
      })
    );

    const transaction = transactionBuilder.setTimeout(0).build();
    transaction.sign(StellarSdk.Keypair.fromSecret(account.secret));

    console.log("⏳ Submitting trustline transaction...");
    const trustResult = await server.submitTransaction(transaction);
    console.log("✅ Trustline established:", trustResult.hash);

    // Step 2: Get the pool ID and deposit initial liquidity
    console.log("\n💰 Step 2: Depositing initial liquidity...");
    
    const accountDataReloaded = await server.loadAccount(account.publicKey);
    let poolId = null;
    
    // Find the liquidity pool share balance
    for (const balance of accountDataReloaded.balances) {
      if (balance.asset_type === "liquidity_pool_shares") {
        poolId = balance.liquidity_pool_id;
        console.log("📊 New Pool ID:", poolId);
        break;
      }
    }

    if (!poolId) {
      throw new Error("Could not find new liquidity pool ID");
    }

    // Deposit initial liquidity
    const depositTransaction = new StellarSdk.TransactionBuilder(accountDataReloaded, txOptions)
      .addOperation(
        StellarSdk.Operation.liquidityPoolDeposit({
          liquidityPoolId: poolId,
          maxAmountA: initialAmountA,
          maxAmountB: initialAmountB,
          minPrice: "0.01",
          maxPrice: "100",
        })
      )
      .setTimeout(0)
      .build();

    depositTransaction.sign(StellarSdk.Keypair.fromSecret(account.secret));
    const depositResult = await server.submitTransaction(depositTransaction);
    
    console.log("✅ Initial liquidity deposited:", depositResult.hash);
    console.log("🎉 New pool created successfully!");

    // Get final pool details
    const poolDetails = await server.liquidityPools().liquidityPoolId(poolId).call();
    console.log(`\n📊 Final pool details:`);
    console.log(`   Pool ID: ${poolId}`);
    console.log(`   Asset A: ${poolDetails.reserves[0].asset} (${poolDetails.reserves[0].amount})`);
    console.log(`   Asset B: ${poolDetails.reserves[1].asset} (${poolDetails.reserves[1].amount})`);
    console.log(`   Total Shares: ${poolDetails.total_shares}`);
    console.log(`   Fee: ${poolDetails.fee_bp} basis points`);

    return {
      poolId,
      trustTransaction: trustResult,
      depositTransaction: depositResult,
      poolDetails
    };

  } catch (error) {
    console.error("❌ Failed to create new pool:", error.message);
    if (error.response?.data?.extras) {
      console.error("Details:", JSON.stringify(error.response.data.extras, null, 2));
    }
    throw error;
  }
};

/**
 * Create predefined pool configurations
 */
const createPredefinedPools = async () => {
  const poolConfigs = [
    {
      name: "MEME-USPI Pool",
      assetA: "MEME",
      assetB: "USPI",
      feeBp: 50, // 0.5% fee
      initialAmountA: "100",
      initialAmountB: "100",
      accountType: "distributor"
    },
    {
      name: "MEME-BBC Pool",
      assetA: "MEME", 
      assetB: "BBC",
      feeBp: 100, // 1% fee
      initialAmountA: "50",
      initialAmountB: "50",
      accountType: "distributor"
    },
    {
      name: "High Fee Test-π-MEME Pool",
      assetA: "Test-π",
      assetB: "MEME",
      feeBp: 500, // 5% fee
      initialAmountA: "20",
      initialAmountB: "200",
      accountType: "distributor"
    }
  ];

  console.log("🏊 Creating predefined pools...\n");

  for (const config of poolConfigs) {
    try {
      console.log(`\n${'='.repeat(50)}`);
      await createNewPool(config);
      console.log(`${'='.repeat(50)}\n`);
    } catch (error) {
      console.error(`❌ Failed to create ${config.name}:`, error.message);
    }
  }
};

// Command line usage
const main = async () => {
  const args = process.argv.slice(2);
  
  if (args.length === 0) {
    console.log("📖 Usage: node createPool.js <COMMAND> [OPTIONS]");
    console.log("\nCommands:");
    console.log("  predefined - Create predefined pool configurations");
    console.log("  custom     - Create custom pool with parameters");
    console.log("\nCustom pool options:");
    console.log("  node createPool.js custom MEME USPI 30 100 100");
    console.log("  node createPool.js custom Test-π MEME 50 20 200");
    console.log("\nParameters for custom:");
    console.log("  ASSET_A      - First asset (MEME, USPI, Test-π, etc.)");
    console.log("  ASSET_B      - Second asset");
    console.log("  FEE_BP       - Fee in basis points (default: 30)");
    console.log("  AMOUNT_A     - Initial amount of asset A");
    console.log("  AMOUNT_B     - Initial amount of asset B");
    console.log("  ACCOUNT      - Account to use (distributor/buyer)");
    process.exit(1);
  }

  const command = args[0];

  if (command === "predefined") {
    await createPredefinedPools();
  } else if (command === "custom") {
    if (args.length < 6) {
      console.error("❌ Custom pool requires: ASSET_A ASSET_B FEE_BP AMOUNT_A AMOUNT_B");
      process.exit(1);
    }

    const poolConfig = {
      assetA: args[1],
      assetB: args[2],
      feeBp: parseInt(args[3]) || 30,
      initialAmountA: args[4],
      initialAmountB: args[5],
      accountType: args[6] || "distributor",
      poolName: `${args[1]}-${args[2]} Pool`
    };

    await createNewPool(poolConfig);
  } else {
    console.error("❌ Invalid command. Use 'predefined' or 'custom'");
    process.exit(1);
  }
};

// Only run main if this file is executed directly
if (process.argv[1].endsWith('createPool.js')) {
  main().catch((error) => {
    console.error("\n❌ Error:", error.message);
    process.exit(1);
  });
}

export { createNewPool, createPredefinedPools };