Example Deployment Guide

# 1. Install dependencies
pnpm install
 
# 2. Build contracts (optional - script will compile if needed)
pnpm contracts:build
 
# 3. Start local blockchain with proper configuration
pnpm anvil-arm --port 8544   # For ARM-based systems (M1/M2 Macs)
# or
pnpm anvil-amd --port 8544   # For AMD/Intel systems

# Deploy the complete protocol infrastructure
pnpm contracts:script script/DeployAll.s.sol

=== Complete Protocol Deployment Finished ===
 
=== Important Addresses to Save ===
ROLES_ADDRESS= 0x5FbDB2315678afecb367f032d93F642f64180aa3
WHITELIST_ADDRESS= 0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0
IFIF_FACTORY_ADDRESS= 0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9

# Deploy DEX components and integrate with factory
pnpm contracts:deploy-dex

🎉 DEX deployment completed successfully!
 
✅ All deployments successful!
Contract addresses: {
  wethAddress: '0x...',
  pairFactoryAddress: '0x...',
  routerAddress: '0x...',
  factoryAddress: '0x...'
}

# Create comprehensive test projects and scenarios
pnpm contracts:deploy-examples

# Create comprehensive IFIFv2 feature demonstration
pnpm contracts:deploy-examples-v2

# Complete example environment setup with both v1 and v2
# Note: Keep anvil running throughout the entire deployment process
 
# 1. Deploy core contracts
pnpm contracts:script script/DeployAll.s.sol
 
# 2. Deploy DEX infrastructure  
pnpm contracts:deploy-dex
 
# 3. Deploy IFIF v1 example projects
pnpm contracts:deploy-examples
 
# 4. Deploy IFIFv2 comprehensive demonstration
pnpm contracts:deploy-examples-v2
 
echo "🎉 Complete IFIF v1 + v2 environment ready!"

# You must run Steps 1-3 first:
pnpm contracts:script script/DeployAll.s.sol
pnpm contracts:deploy-dex
pnpm contracts:deploy-examples  # Required for USDC and SignatureHelper
 
# Then update CONTRACT_ADDRESSES in contracts/deployV2Examples.ts
# Set all addresses to match your deployed contracts from Steps 1-3
 
# Finally deploy v2 demonstration
pnpm contracts:deploy-examples-v2
 
echo "🚀 IFIFv2 demonstration complete!"

// Contract addresses from deployment (addresses will vary per deployment)
// These are example addresses - use actual addresses from your deployment output
const CONTRACT_ADDRESSES = {
  ROLES: '0x5FbDB2315678afecb367f032d93F642f64180aa3',
  WHITELIST: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0', 
  FACTORY: '0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9',
  USDC_TOKEN: '0x0b306bf915c4d645ff596e518faf3f9669b97016', // Mock USDC from deployExamples
  SIGNATURE_HELPER: '0x9a676e781a523b5d0c0e43731313a708cb607508', // From deployExamples
  // v1 projects: IDs 1-5 (use factory.deployments(projectId) to get addresses)
  // v2 project: ID 100 (comprehensive demonstration)
}
 
// Use with wagmi or viem for contract interactions
const factory = getContract({
  address: CONTRACT_ADDRESSES.FACTORY,
  abi: ififFactoryAbi,
  client: publicClient
})
 
// Get project details (works for both v1 and v2)
const projectDetails = await factory.read.getProject([projectId])
 
// Get actual project contract address
const projectAddress = await factory.read.deployments([projectId])
 
// v2-specific features (only for project ID 100)
const v2Project = getContract({
  address: projectAddress, // Use actual deployed address
  abi: ififv2Abi, // Use v2 ABI for enhanced features
  client: publicClient
})
 
// Check if project has v2 features
const hasV2Features = projectId === 100n // Project 100 is the v2 demonstration project

# Start indexer after complete deployment
pnpm indexer:dev
 
# The indexer will process events from both versions:
# v1 Events (Projects 1-5):
# - Project creations and stage transitions
# - Investment transactions and refunds
# - NFT operations and transfers
# - Role management activities
# - Whitelist updates
 
# v2 Events (Project 100):
# - Enhanced purchase events with cap validation
# - Multi-distributor configuration updates
# - Fund vesting configuration and claims
# - Token vesting setup and progressive claims
# - NFT conversion and burn operations
# - Asset recovery sweep events

// Test with real deployed contracts (both v1 and v2)
describe('IFIF Integration Tests', () => {
  // v1 Tests
  it('should handle v1 project lifecycle', async () => {
    // Test against deployed v1 project 1 (successful project)
    const project = await factory.read.getProject([1])
    expect(project.stage).toBe(4n) // 4 = SALE_SUCCESSED stage
  })
  
  it('should process v1 investor NFT operations', async () => {
    // Get project contract address and test NFT functionality
    const projectAddress = await factory.read.deployments([1])
    const projectContract = getContract({ 
      address: projectAddress, 
      abi: ififAbi,
      client: publicClient 
    })
    const nftBalance = await projectContract.read.balanceOf([ACCOUNTS.ACCOUNT_4])
    expect(nftBalance).toBeGreaterThan(0n)
  })
 
  // v2 Tests  
  it('should handle v2 project with enhanced features', async () => {
    // Test against deployed v2 project 100
    const v2Project = await factory.read.getProject([100])
    expect(v2Project.stage).toBe(6n) // 6 = CLAIM stage after deposits
  })
 
  it('should validate v2 purchase controls', async () => {
    // Test v2 purchase cap enforcement
    const v2ProjectAddress = await factory.read.deployments([100])
    const v2Contract = getContract({ 
      address: v2ProjectAddress, 
      abi: ififv2Abi,
      client: publicClient 
    })
    const config = await v2Contract.read.config_v2()
    expect(config.purchaseHardCapPercent).toBe(20n) // 20% hard cap
    expect(config.purchaseSoftCap).toBe(parseEther('1000')) // 1k USDC soft cap
  })
 
  it('should process v2 multi-distributor system', async () => {
    // Test multiple distributors with different fee structures
    const v2ProjectAddress = await factory.read.deployments([100])
    const v2Contract = getContract({ 
      address: v2ProjectAddress, 
      abi: ififv2Abi,
      client: publicClient 
    })
    const distributors = [ACCOUNTS.ACCOUNT_2, ACCOUNTS.ACCOUNT_8, ACCOUNTS.ACCOUNT_9]
    for (const distributor of distributors) {
      const config = await v2Contract.read.distributorConfigs([distributor])
      expect(config.distributorFeePercent).toBeGreaterThan(0n)
    }
  })
 
  it('should validate v2 vesting systems', async () => {
    // Test dual vesting system (fund + token)
    const v2ProjectAddress = await factory.read.deployments([100])
    const v2Contract = getContract({ 
      address: v2ProjectAddress, 
      abi: ififv2Abi,
      client: publicClient 
    })
    const fundConfig = await v2Contract.read.fundClaimConfig()
    expect(fundConfig.periodLength).toBe(7n * 24n * 60n * 60n) // 7 days = 604800 seconds
    
    // Token vesting configured through updateClaimConfig
    // Test vesting progression and claim availability
    const claimConfig = await v2Contract.read.claimConfig()
    expect(claimConfig.periodLength).toBe(7n * 24n * 60n * 60n) // Weekly unlocks
  })
})

# Set contract addresses from deployment output (update with your actual addresses)
export ROLES_ADDRESS=0x5FbDB2315678afecb367f032d93F642f64180aa3
export FACTORY_ADDRESS=0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9
export USDC_ADDRESS=0x0b306bf915c4d645ff596e518faf3f9669b97016
 
# Check core contract deployment
cast call $ROLES_ADDRESS "owner()" --rpc-url http://localhost:8544
 
# Verify factory configuration (should be v2 after deployV2Examples)
cast call $FACTORY_ADDRESS "implementation()" --rpc-url http://localhost:8544
 
# Check specific project deployments (factory.deployments(projectId) returns project address)
# Project 1 (v1)
cast call $FACTORY_ADDRESS "deployments(uint256)" 1 --rpc-url http://localhost:8544
 
# Project 100 (v2)
cast call $FACTORY_ADDRESS "deployments(uint256)" 100 --rpc-url http://localhost:8544
 
# Get v2 project contract address and check v2-specific features
V2_PROJECT=$(cast call $FACTORY_ADDRESS "deployments(uint256)" 100 --rpc-url http://localhost:8544)
cast call $V2_PROJECT "stage()" --rpc-url http://localhost:8544 # Should be 6 (CLAIM)
cast call $V2_PROJECT "totalPurchase()" --rpc-url http://localhost:8544 # Should be 50k USDC (50000000000000000000000)

# Check investor USDC balances (should reflect both v1 and v2 participation)
cast call $USDC_ADDRESS "balanceOf(address)" 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url http://localhost:8544 # ACCOUNT_4
cast call $USDC_ADDRESS "balanceOf(address)" 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 --rpc-url http://localhost:8544 # ACCOUNT_5
 
# Get project contract addresses first
V1_PROJECT_1=$(cast call $FACTORY_ADDRESS "deployments(uint256)" 1 --rpc-url http://localhost:8544)
V2_PROJECT=$(cast call $FACTORY_ADDRESS "deployments(uint256)" 100 --rpc-url http://localhost:8544)
 
# Verify v1 project investments (project 1 should have investments from deployment)
cast call $V1_PROJECT_1 "totalPurchase()" --rpc-url http://localhost:8544
 
# Check v1 project stage (should be 4 = SALE_SUCCESSED for most projects)
cast call $V1_PROJECT_1 "stage()" --rpc-url http://localhost:8544
 
# Verify v2 project investment (project 100 - should be 50k USDC)
cast call $V2_PROJECT "totalPurchase()" --rpc-url http://localhost:8544
 
# Check v2 project stage (should be 6 = CLAIM after all deposits)
cast call $V2_PROJECT "stage()" --rpc-url http://localhost:8544
 
# Check v1 NFT allocations (investors who claimed NFTs)
cast call $V1_PROJECT_1 "balanceOf(address)" 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url http://localhost:8544 # ACCOUNT_4
 
# Check v2 NFT operations (may be 0 if converted back to tokens)
cast call $V2_PROJECT "balanceOf(address)" 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url http://localhost:8544 # ACCOUNT_4
 
# Verify v2 purchase controls (specific to v2 projects)
cast call $V2_PROJECT "config_v2()" --rpc-url http://localhost:8544
 
# Check multi-distributor configurations in v2
cast call $V2_PROJECT "distributorConfigs(address)" 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC --rpc-url http://localhost:8544 # ACCOUNT_2 (Distributor 1)
cast call $V2_PROJECT "distributorConfigs(address)" 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 --rpc-url http://localhost:8544 # ACCOUNT_8 (Distributor 2) 
cast call $V2_PROJECT "distributorConfigs(address)" 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 --rpc-url http://localhost:8544 # ACCOUNT_9 (Distributor 3)
 
# Verify v2 vesting configurations
cast call $V2_PROJECT "fundClaimConfig()" --rpc-url http://localhost:8544    # Fund vesting for project owner
cast call $V2_PROJECT "claimConfig()" --rpc-url http://localhost:8544        # Token vesting for investors

# Update CONTRACT_ADDRESSES in deployDex.ts, deployExamples.ts, and deployV2Examples.ts
# with actual deployed addresses from DeployAll output
 
# For deployExamples.ts, update these addresses:
const CONTRACT_ADDRESSES = {
  ROLES: '0x5FbDB2315678afecb367f032d93F642f64180aa3',
  WHITELIST: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0',
  FACTORY: '0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9',
  IFIF_IMPLEMENTATION: '0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9'
}
 
# For deployV2Examples.ts, ensure all addresses match deployed contracts:
# - USDC_TOKEN and SIGNATURE_HELPER come from deployExamples.ts
# - All other addresses must match DeployAll.s.sol output

# Reset anvil state completely
rm -rf anvil-state/ anvil-state-amd/
 
# Restart anvil with correct port and state preservation
pnpm anvil-arm --port 8544  # For ARM-based systems (M1/M2 Macs)
# or
pnpm anvil-amd --port 8544  # For AMD/Intel systems
 
# Important: Always specify --port 8544 to match deployment scripts

# Common causes:
# 1. Wrong domain separator (chain ID mismatch)
# 2. Incorrect struct encoding
# 3. Wrong signer account
 
# Verify chain ID matches anvil (should be 31337)
cast chain-id --rpc-url http://localhost:8544
 
# Ensure MANAGER_ROLE is properly assigned to ACCOUNT_3
# Check role assignments in deployment logs

# Verify factory contract has correct admin permissions
cast call $FACTORY_ADDRESS "owner()" --rpc-url http://localhost:8544
 
# Check current implementation
cast call $FACTORY_ADDRESS "implementation()" --rpc-url http://localhost:8544
 
# Manually update implementation if needed (as admin/owner)
cast send $FACTORY_ADDRESS "updateImplementation(address)" $V2_IMPLEMENTATION_ADDRESS \
  --rpc-url http://localhost:8544 --private-key $ADMIN_PRIVATE_KEY

# Check project's purchase controls
cast call $V2_PROJECT "config_v2()" --rpc-url http://localhost:8544
 
# Common issues:
# - Purchase amount below soft cap (1000 USDC minimum)
# - User exceeding hard cap percentage (20% of total)
# - Insufficient USDC balance or allowance
 
# Verify USDC allowance
cast call $USDC_ADDRESS "allowance(address,address)" $USER_ADDRESS $V2_PROJECT --rpc-url http://localhost:8544

# Check current project stage
cast call $PROJECT_ADDRESS "stage()" --rpc-url http://localhost:8544
 
# Verify time progression (anvil might need manual time advancement)
cast call $PROJECT_ADDRESS "activeSaleEndTime()" --rpc-url http://localhost:8544
 
# Common stage issues:
# - Stage 0 (NONE): Project not properly initialized
# - Stage 1 (INIT): Waiting for sale start time
# - Stage 2/3: Sale periods active
# - Stage 4 (SALE_SUCCESSED): Ready for deposits/claims
# - Stage 6 (CLAIM): After first deposit (V2 projects)

# Check anvil logs for detailed error messages
# Common issues:
 
# 1. Insufficient ETH for gas
cast balance $ACCOUNT_ADDRESS --rpc-url http://localhost:8544
 
# 2. Insufficient USDC balance
cast call $USDC_ADDRESS "balanceOf(address)" $ACCOUNT_ADDRESS --rpc-url http://localhost:8544
 
# 3. Missing role permissions
cast call $ROLES_ADDRESS "hasRole(bytes32,address)" $ROLE_HASH $ACCOUNT_ADDRESS --rpc-url http://localhost:8544
 
# 4. Contract addresses incorrect
# Verify all addresses exist and are contracts (not EOAs)

# Vesting must be configured in correct order:
# 1. Fund vesting (in SALE_SUCCESSED stage)  
# 2. Token deposits (transitions to CLAIM stage)
# 3. Token vesting (in CLAIM stage)
 
# Check current vesting configurations
cast call $V2_PROJECT "fundClaimConfig()" --rpc-url http://localhost:8544
cast call $V2_PROJECT "claimConfig()" --rpc-url http://localhost:8544
 
# Verify vesting periods are reasonable (604800 = 7 days)

# Verify anvil is running on correct port
curl -X POST -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
  http://localhost:8544
 
# Check if port 8544 is in use
lsof -i :8544
 
# Restart anvil with explicit port
pnpm anvil-arm --port 8544  # Must specify port, defaults to 8545

# Deployment scripts are configured for http://localhost:8544
# Anvil defaults to port 8545 without --port flag
 
# Always start anvil with explicit port:
pnpm anvil-arm --port 8544  # ARM systems
pnpm anvil-amd --port 8544  # AMD/Intel systems
 
# Or update RPC_URL in deployment scripts:
const RPC_URL = 'http://localhost:8544'  # Must match anvil port

# Verify account addresses match anvil defaults:
# Account 0: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
# Account 1: 0x70997970C51812dc3A010C7d01b50e0d17dc79C8
# ... (standard anvil test accounts)
 
# Check account balances (should have 10,000 ETH each)
cast balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url http://localhost:8544
 
# Verify private keys match anvil test accounts
# Account 0 private key: 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80

# Ensure compatible versions:
node --version  # Should be v18+ 
pnpm --version  # Should be v8+
 
# Install/update dependencies
pnpm install
 
# Clear cache if needed
pnpm store prune
rm -rf node_modules pnpm-lock.yaml
pnpm install

# Update foundry
foundryup
 
# Clean and rebuild
pnpm contracts:build
# or manually:
cd contracts && forge clean && forge build
 
# Verify forge can access remappings
cd contracts && forge remappings

// Customize v1 project settings
const customProjectConfig = {
  fundToken: usdcAddress,
  projectId: 6n, // Next available ID after existing 5 (must be bigint)
  fundAmount: parseEther('25000'), // 25k USDC target
  privateSaleTime: BigInt(5 * 24 * 60 * 60), // 5 days duration (not epoch time)
  privateBonusPercent: 15n, // 15% bonus (must be bigint)
  publicSaleTime: BigInt(10 * 24 * 60 * 60), // 10 days duration (not epoch time)
  desiredEndEpoch: BigInt(Date.now() / 1000 + (30 * 24 * 60 * 60)) // 30 days from now (epoch time)
}
 
const customProjectNextConfig = {
  projectOwner: ACCOUNTS.ACCOUNT_1,
  distributor: ACCOUNTS.ACCOUNT_2,
  distributorFeePercent: 3n, // 3% distributor fee
  projectOwnerFeePercent: 5n, // 5% project owner fee
  platformFeePercent: 2n, // 2% platform fee
  pairPrice: parseEther('0.1') // 0.1 USDC per token
}

// Customize v2 project settings (unified demonstration)
const customV2ProjectConfig = {
  fundToken: usdcAddress as `0x${string}`,
  projectId: 101n, // Next available ID after demo project 100
  fundAmount: parseEther('75000'), // 75k USDC target
  privateSaleTime: 3600n, // 1 hour duration (not epoch time)
  privateBonusPercent: 25n, // 25% bonus
  publicSaleTime: 7200n, // 2 hours duration (not epoch time)
  desiredEndEpoch: BigInt(Date.now() / 1000 + 14400) // 4 hours from now (epoch time)
}
 
const customV2ProjectNextConfig = {
  projectOwner: ACCOUNTS.ACCOUNT_1 as `0x${string}`,
  distributor: ACCOUNTS.ACCOUNT_2 as `0x${string}`, // Primary distributor
  distributorFeePercent: 2n,
  projectOwnerFeePercent: 5n,
  platformFeePercent: 2n,
  pairPrice: parseEther('0.1')
}
 
// v2-specific enhancements
const customV2ProjectConfigV2 = {
  privateSaleStartEpoch: BigInt(Date.now() / 1000 + 300), // 5 minutes from now
  purchaseHardCapPercent: 15n, // 15% max per user (11,250 USDC for 75k target)
  purchaseSoftCap: parseEther('2000'), // 2k USDC minimum purchase
  minNFTWeight: 200n // NFT splitting minimum weight (200 units)
}

// Add custom v1 investor behavior
const customV1Investments = [
  {
    account: ACCOUNTS.ACCOUNT_4,
    projectId: 6n,
    amount: parseEther('5000'),
    stage: 'private', // During private sale period
    description: 'Early investor with bonus'
  },
  {
    account: ACCOUNTS.ACCOUNT_5,
    projectId: 6n,
    amount: parseEther('3000'),
    stage: 'public', // During public sale period
    description: 'Standard public sale investment'
  },
  {
    account: ACCOUNTS.ACCOUNT_6,
    projectId: 6n,
    amount: parseEther('7500'),
    stage: 'private',
    description: 'Large private investment'
  }
]
 
// Execute investments with proper timing
for (const investment of customV1Investments) {
  // Set appropriate stage timing before purchase
  if (investment.stage === 'private') {
    await setBlockTimestamp(testClient, privateStartTime)
  } else {
    await setBlockTimestamp(testClient, publicStartTime)
  }
  
  // Execute purchase with proper transaction structure
  await executePurchase(
    testClient,
    investment.projectId,
    investment.account,
    usdcAddress,
    investment.amount,
    investment.description
  )
}

// v2 investment scenarios with cap validation
const v2PurchaseScenarios = [
  { 
    account: ACCOUNTS.ACCOUNT_4,
    projectId: 101n,
    amount: parseEther('5000'),
    description: 'Valid: Above 2k soft cap, within 15% hard cap',
    stage: 'private',
    shouldSucceed: true
  },
  { 
    account: ACCOUNTS.ACCOUNT_5,
    projectId: 101n,
    amount: parseEther('11250'), // Exactly at 15% hard cap (75k * 0.15)
    description: 'Valid: Maximum allowed per user',
    stage: 'private',
    shouldSucceed: true
  },
  { 
    account: ACCOUNTS.ACCOUNT_6,
    projectId: 101n,
    amount: parseEther('1500'), // Below 2k soft cap
    description: 'Invalid: Below 2k soft cap - will fail',
    stage: 'public',
    shouldSucceed: false
  },
  {
    account: ACCOUNTS.ACCOUNT_7,
    projectId: 101n,
    amount: parseEther('12000'), // Above 15% hard cap
    description: 'Invalid: Exceeds 15% hard cap - will fail',
    stage: 'public',
    shouldSucceed: false
  }
]
 
// Execute v2 purchases with enhanced validation
for (const scenario of v2PurchaseScenarios) {
  try {
    // Set appropriate stage timing
    if (scenario.stage === 'private') {
      await setBlockTimestamp(testClient, privateStartTime)
    } else {
      await setBlockTimestamp(testClient, publicStartTime)
    }
    
    // Execute v2 purchase with enhanced controls
    await executeV2Purchase(
      testClient,
      scenario.projectId,
      scenario.account,
      usdcAddress,
      scenario.amount,
      scenario.description
    )
    
    if (!scenario.shouldSucceed) {
      console.log(`   ⚠️ Expected failure but transaction succeeded: ${scenario.description}`)
    }
  } catch (error: any) {
    if (scenario.shouldSucceed) {
      console.log(`   ❌ Unexpected failure: ${scenario.description} - ${error.message}`)
    } else {
      console.log(`   ✅ Expected failure: ${scenario.description} - ${error.message}`)
    }
  }
}

// Import time utilities from deployment scripts
import { advanceTimeAndTrack, setBlockTimestampAndTrack } from './deployExamples'
 
// Advance time for specific testing scenarios
const sevenDays = 7 * 24 * 60 * 60 // 7 days in seconds
await advanceTimeAndTrack(testClient, sevenDays)
 
// Set specific timestamp for testing stage transitions
const futureTimestamp = Math.floor(Date.now() / 1000) + (30 * 60) // 30 minutes from now
await setBlockTimestampAndTrack(testClient, futureTimestamp)
 
// Example: Fast-forward through project stages
const projectStartTime = Math.floor(Date.now() / 1000)
const privateStartTime = projectStartTime + 300 // 5 minutes delay
const publicStartTime = privateStartTime + 1800 // 30 minutes private sale
const saleEndTime = publicStartTime + 3600 // 1 hour public sale
 
// Test private sale phase
await setBlockTimestampAndTrack(testClient, privateStartTime)
console.log('⏰ Time advanced to private sale start')
 
// Test public sale phase  
await setBlockTimestampAndTrack(testClient, publicStartTime)
console.log('⏰ Time advanced to public sale start')
 
// Test sale completion
await setBlockTimestampAndTrack(testClient, saleEndTime)
console.log('⏰ Time advanced to sale end')
 
// Advanced time manipulation for vesting tests
const vestingPeriod = 7 * 24 * 60 * 60 // 7 days
await advanceTimeAndTrack(testClient, vestingPeriod)
console.log('⏰ Advanced by one vesting period')

// Define multiple distributors with unique fee structures
const distributorConfigs = [
  {
    distributorAddress: ACCOUNTS.ACCOUNT_2,
    distributorFeePercent: 2n, // 2% fee
    projectOwnerFeePercent: 5n, // 5% to project owner
    platformFeePercent: 2n, // 2% to platform
    description: 'Conservative fee distributor'
  },
  {
    distributorAddress: ACCOUNTS.ACCOUNT_8,
    distributorFeePercent: 3n, // 3% fee
    projectOwnerFeePercent: 4n, // 4% to project owner
    platformFeePercent: 2n, // 2% to platform
    description: 'Balanced fee distributor'
  },
  {
    distributorAddress: ACCOUNTS.ACCOUNT_9,
    distributorFeePercent: 1n, // 1% fee
    projectOwnerFeePercent: 6n, // 6% to project owner
    platformFeePercent: 1n, // 1% to platform
    description: 'Low fee high owner reward distributor'
  }
]
 
// Example: Setting up deposits with multiple distributors
const multiDistributorDeposits = [
  {
    distributor: ACCOUNTS.ACCOUNT_2,
    amount: parseEther('10000'), // 10k USDC
    signers: [ACCOUNTS.ACCOUNT_3, ACCOUNTS.ACCOUNT_2, ACCOUNTS.ACCOUNT_1] // Manager, Distributor, Owner
  },
  {
    distributor: ACCOUNTS.ACCOUNT_8,
    amount: parseEther('15000'), // 15k USDC
    signers: [ACCOUNTS.ACCOUNT_3, ACCOUNTS.ACCOUNT_8, ACCOUNTS.ACCOUNT_1]
  },
  {
    distributor: ACCOUNTS.ACCOUNT_9,
    amount: parseEther('12000'), // 12k USDC
    signers: [ACCOUNTS.ACCOUNT_3, ACCOUNTS.ACCOUNT_9, ACCOUNTS.ACCOUNT_1]
  }
]
 
// Execute multi-distributor deposits (requires 3-signature validation)
for (const deposit of multiDistributorDeposits) {
  // Create deposit configuration with proper signatures
  const depositConfig = {
    distributor: deposit.distributor,
    amount: deposit.amount,
    // Additional V2 deposit parameters...
  }
  
  // Generate required signatures from all three parties
  const signatures = await generateMultiDistributorSignatures(
    depositConfig,
    deposit.signers
  )
  
  // Execute deposit with proper validation
  await executeMultiDistributorDeposit(
    testClient,
    projectId,
    depositConfig,
    signatures
  )
}

// Fund vesting configuration (for project owner)
const fundVestingConfig = {
  startEpoch: BigInt(Math.floor(Date.now() / 1000)), // Start now
  endEpoch: BigInt(Math.floor(Date.now() / 1000) + (90 * 24 * 60 * 60)), // 90 days
  periodLength: BigInt(7 * 24 * 60 * 60), // 7 days per period
  description: 'Progressive fund claiming over 90 days'
}
 
// Token vesting configuration (for investors)  
const tokenVestingConfig = {
  startEpoch: BigInt(Math.floor(Date.now() / 1000) + (7 * 24 * 60 * 60)), // Start in 7 days
  endEpoch: BigInt(Math.floor(Date.now() / 1000) + (12 * 7 * 24 * 60 * 60)), // 12 weeks total
  periodLength: BigInt(7 * 24 * 60 * 60), // Weekly unlocks
  description: '12-week progressive token vesting'
}
 
// Apply vesting configurations to V2 project
await configureV2Vesting(
  testClient,
  v2ProjectAddress,
  fundVestingConfig,
  tokenVestingConfig
)

# Start the frontend with deployed contracts
cd examples
pnpm dev
 
# Frontend runs on http://localhost:4000 (not default 3000)
# This connects to the indexer on http://localhost:42069

# Start indexer first (processes deployed contract events)
pnpm indexer:dev
 
# The indexer processes events from both v1 and v2 projects:
# - v1 Projects (IDs 1-5): Traditional IFIF events
# - v2 Project (ID 100): Enhanced v2 events + all v1 events
# - Indexer creates unified data views for frontend consumption

// Frontend focuses on core IFIF features across both versions:
// - Project lifecycle tracking (all stages)
// - Investment history and portfolio views  
// - NFT ownership and basic operations
// - Role-based access control management
// - Whitelist administration
// - General analytics and reporting

// Production ponder.config.ts adjustments:
export default createConfig({
  chains: {
    mainnet: { // Replace anvil with actual network
      id: 1,
      rpc: process.env.RPC_URL, // Use environment variables
      maxRpcRequestConcurrency: 10,
      pollingInterval: 2000
    }
  },
  contracts: {
    // Update with actual deployed contract addresses
    Factory: {
      address: process.env.FACTORY_ADDRESS, // Not hard-coded
      startBlock: DEPLOYMENT_BLOCK, // Start from deployment block
    },
    // Configure for multiple chains if needed
  },
  database: {
    // Production database configuration
    kind: "postgres",
    connectionString: process.env.DATABASE_URL,
    pool: { max: 20 }
  }
})

# Local development (current setup)
pnpm anvil-arm --port 8544          # Local blockchain
pnpm indexer:dev                    # Ponder dev mode
pnpm contracts:deploy-examples      # Deploy test contracts

# Production deployment flow
export RPC_URL="https://mainnet.infura.io/v3/YOUR_KEY"
export DATABASE_URL="postgresql://user:pass@host:5432/db"
export FACTORY_ADDRESS="0x..." # Actual deployed factory
 
pnpm indexer:build                  # Build optimized indexer
pnpm indexer:start                  # Start production indexer
# + Docker containerization
# + Load balancer configuration
# + Monitoring setup