Contributing to POTLAUNCH

# Update your fork
git checkout main
git pull upstream main
 
# Create feature branch
git checkout -b feature/your-feature-name
 
# Or bug fix branch
git checkout -b fix/bug-description

// ✅ Good: Clear, documented code
/**
 * Calculate bonding curve price for given supply
 * @param supply Current token supply
 * @param config Curve configuration
 * @returns Price in lamports
 */
function calculatePrice(supply: number, config: CurveConfig): number {
  const { initialPrice, exponent } = config;
  return initialPrice * Math.pow(supply / 1e9, exponent);
}
 
// ❌ Bad: Unclear, undocumented
function calc(s: number, c: any): number {
  return c.ip * Math.pow(s / 1e9, c.e);
}

// Always include tests
describe('calculatePrice', () => {
  it('returns initial price for zero supply', () => {
    const price = calculatePrice(0, {
      initialPrice: 1000,
      exponent: 1.5,
    });
    expect(price).toBe(1000);
  });
  
  it('increases price with supply', () => {
    const config = { initialPrice: 1000, exponent: 1.5 };
    const price1 = calculatePrice(1e8, config);
    const price2 = calculatePrice(2e8, config);
    expect(price2).toBeGreaterThan(price1);
  });
});

// Document complex logic
/**
 * Graduates token to DEX when criteria are met
 * 
 * Process:
 * 1. Verify graduation eligibility
 * 2. Extract liquidity from bonding curve
 * 3. Create DEX pool on Raydium
 * 4. Burn LP tokens for permanent lock
 * 5. Update launch state
 * 
 * @param launchState Launch state PDA
 * @throws {NotEligibleError} If graduation criteria not met
 * @throws {InsufficientLiquidityError} If reserve too low
 */
async function graduateToDex(launchState: PublicKey): Promise<void> {
  // Implementation
}

# Format: <type>(<scope>): <description>
 
# Examples:
git commit -m "feat(launch): add logarithmic bonding curve"
git commit -m "fix(trading): correct price calculation precision"
git commit -m "docs(sdk): add usage examples"
git commit -m "test(curve): add edge case tests"

# Push to your fork
git push origin feature/your-feature-name
 
# Create pull request on GitHub
# Fill in the PR template

[Type] Brief description

Examples:
[Feature] Add logarithmic bonding curve support
[Fix] Correct price calculation in edge cases
[Docs] Improve SDK installation instructions

## Description
Brief description of changes
 
## Motivation
Why is this change needed?
 
## Changes
- Change 1
- Change 2
- Change 3
 
## Testing
How was this tested?
 
## Screenshots
(if applicable)
 
## Checklist
- [ ] Tests added/updated
- [ ] Documentation updated
- [ ] No breaking changes
- [ ] Follows code style
- [ ] PR title follows format

# Good responses:
 
"Good catch! I've updated the logic as you suggested."
 
"That's a great point. I've added tests for that case."
 
"I'm not sure I understand. Could you elaborate on X?"
 
# Keep discussion constructive and professional

// Use TypeScript strict mode
// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true
  }
}
 
// Prefer const over let
const config = loadConfig();
let mutableState = initialState;
 
// Use descriptive names
const bondingCurvePrice = calculatePrice(supply);
// Not: const p = calc(s);
 
// Document complex types
interface LaunchConfiguration {
  /** Token mint public key */
  tokenMint: PublicKey;
  /** Bonding curve type */
  curveType: 'linear' | 'exponential' | 'logarithmic';
  /** Initial price in lamports */
  initialPrice: number;
}

// Follow Rust conventions
use anchor_lang::prelude::*;
 
/// Launch state account
#[account]
pub struct LaunchState {
    /// Token mint address
    pub token_mint: Pubkey,
    /// Creator address
    pub creator: Pubkey,
    /// Current sold supply
    pub sold_supply: u64,
    /// State bump seed
    pub bump: u8,
}
 
// Use descriptive error messages
#[error_code]
pub enum ErrorCode {
    #[msg("Slippage tolerance exceeded")]
    SlippageExceeded,
    #[msg("Not eligible for graduation")]
    NotEligible,
}
 
// Document public functions
/// Calculate bonding curve price
/// 
/// # Arguments
/// * `supply` - Current token supply
/// * `config` - Curve configuration
/// 
/// # Returns
/// Price in lamports
pub fn calculate_price(supply: u64, config: &CurveConfig) -> Result<u64> {
    // Implementation
}

// Unit tests
describe('PriceCalculator', () => {
  // Group related tests
  describe('calculatePrice', () => {
    // Descriptive test names
    it('should return initial price for zero supply', () => {
      // Arrange
      const calculator = new PriceCalculator(config);
      
      // Act
      const price = calculator.calculatePrice(0);
      
      // Assert
      expect(price).toBe(config.initialPrice);
    });
    
    // Test edge cases
    it('should handle maximum supply', () => {
      const price = calculator.calculatePrice(MAX_SUPPLY);
      expect(price).toBeLessThan(config.maxPrice);
    });
  });
});
 
// Integration tests
describe('Token Launch Flow', () => {
  it('should complete full launch lifecycle', async () => {
    // Initialize
    const launch = await initializeLaunch(params);
    
    // Trade
    await buyTokens(launch, 1000);
    
    // Graduate
    await graduateToDex(launch);
    
    // Verify
    const state = await getLaunchState(launch);
    expect(state.graduated).toBe(true);
  });
});

// ✅ Good: Explain WHY, not WHAT
// Use floating point to avoid precision loss in large calculations
const price = Number(priceInLamports) / LAMPORTS_PER_SOL;
 
// ❌ Bad: Stating the obvious
// Divide price by lamports per sol
const price = priceInLamports / LAMPORTS_PER_SOL;

/**
 * Purchases tokens from a bonding curve launch
 * 
 * @param launchAddress - Public key of the launch state account
 * @param amountSol - Amount of SOL to spend (in lamports)
 * @param maxSlippage - Maximum acceptable slippage (in basis points)
 * @returns Transaction signature
 * 
 * @throws {SlippageExceededError} If price impact exceeds maxSlippage
 * @throws {InsufficientLiquidityError} If not enough tokens available
 * 
 * @example
 * ```typescript
 * // Buy tokens with 1 SOL, max 0.5% slippage
 * const tx = await buyTokens(
 *   launchAddress,
 *   1_000_000_000, // 1 SOL
 *   50 // 0.5%
 * );
 * ```
 */
async function buyTokens(
  launchAddress: PublicKey,
  amountSol: number,
  maxSlippage: number
): Promise<string> {
  // Implementation
}