The $zCoin Manifesto: Decentralized Launchpad

1. Introduction & Vision

The $zCoin Launchpad emerges as a direct response to the pervasive issues plaguing traditional token launch platforms on the Solana blockchain, including opaque presales, insider allocations, rug-pull vulnerabilities, and insufficient liquidity mechanisms. By harnessing the innovative Dynamic Bonding Curve (DBC) protocol from Meteora, $zCoin redefines token launches as fair, transparent, and high-velocity events. This platform not only eliminates common risks but also establishes a self-sustaining ecosystem where trading fees are recycled to reward creators, liquidity providers, traders, and long-term holders alike.

At its core, $zCoin is more than a launchpad—it's a decentralized economic engine that democratizes access to early-stage projects while ensuring that every participant benefits from network growth. With Solana's unparalleled speed (up to 65,000 TPS) and low fees (~$0.00025 per transaction), $zCoin positions itself to capture the explosive demand for meme coins, DeFi primitives, and utility tokens in a market projected to exceed $10 trillion in total value locked by 2030.

Vision Statement

Our vision is to establish $zCoin as the premier decentralized launchpad on Solana, renowned globally for its unwavering commitment to community rewards, innovative liquidity bootstrapping, and unassailable trust through fully auditable, open-source smart contracts. We aim to foster an environment where innovation thrives without the shadows of centralization, empowering thousands of creators to launch projects that could redefine Web3. By 2027, we target facilitating over **2,500 successful launches**, achieving **$100M+ in cumulative DBC trade volume**, and distributing **$15M+ in community rewards**—all while maintaining zero tolerance for exploits or unfair practices.

Core Features

• Instant Liquidity Provision: Every token launch automatically pairs sold tokens with the quote asset (e.g., $SOL) to create permanent, non-withdrawable liquidity pools on Meteora, ensuring seamless trading from minute one. This eliminates the "dead pool" phase common in fair launches, where early buyers face illiquidity risks.
• Community-Driven Rewards Engine: A sophisticated fee-recycling mechanism captures 1.88% of DBC trading fees and redistributes 75% as $SOL rewards weekly, creating a virtuous cycle that incentivizes **holding**, trading, and providing liquidity. Projected annual yield for top **holders** is highly competitive based on conservative volume estimates.
• 100% Fair Launch Protocol: No presales, no private allocations, no team pre-mines. All circulating supply is distributed transparently via bonding curve sales, community incentives, and bootstrapped liquidity, with 5% of total supply permanently burnt at genesis to introduce deflationary mechanics and signal long-term scarcity.
• Anti-Rug Safeguards: Smart contracts enforce linear price discovery on the DBC until full saturation, after which automatic migration to AMM pools occurs. Creators cannot access liquidity until post-migration, verified by on-chain events.

Market Opportunity

Solana's DeFi ecosystem has grown 300% YoY, with launchpads like Pump.fun capturing $2B+ in volume in 2024 alone. However, 70% of launches fail due to trust deficits. $zCoin addresses this by combining DBC's mathematical predictability with community alignment, positioning for a respectable market share within 18 months.

2. Tokenomics (The Flywheel)

The $zCoin utility token serves as the foundational element of our ecosystem, engineered to perpetuate a self-reinforcing Flywheel Effect. This dynamic model ensures that increased platform usage drives token demand, which in turn enhances rewards and adoption, creating exponential value accrual for all stakeholders. With a focus on deflationary mechanics and 100% fair distribution, $zCoin is designed for longevity and alignment with community interests.

$zCoin Utility & Use Cases

$zCoin is not merely a speculative asset but a multifaceted utility and access token. Its utilities are layered to encourage diverse participation:

1. Incentivized Holding & Yield: Holders can lock their $zCoin to earn a proportional share of the weekly $SOL rewards pool based on lock duration and amount. **Holding Multipliers** apply: Basic (1x for 30-day lock), Enhanced (1.5x for 90-day), and Premium (2x for 180-day). This mechanism rewards long-term commitment.
2. Launch Tier Access: $zCoin balances determine eligibility for premium features, such as priority launch slots (e.g., 1,000 $zCoin for Tier 1). Future expansions include fee discounts for high-tier holders, reducing deployer costs by up to 50% for 10,000+ $zCoin balances.
3. Community Status & Incentives: Ownership thresholds unlock exclusive perks, including access to private Discord channels, bounty programs (e.g., $1,000 $SOL for top contributors quarterly), and airdrop multipliers. For instance, holders with 5,000+ $zCoin receive 2x points in loyalty programs, redeemable for merchandise or custom launch support.
4. Liquidity Bootstrapping: A portion of fees auto-compounds into $zCoin/$SOL LP positions, maintaining depth and reducing volatility. Target: 5% of circulating supply in locked LPs within Year 1.

Token Supply & Distribution

The total supply is fixed at 1,000,000,000 $zCoin, ensuring predictability and scarcity. To promote fairness and deflation, **57,000,000 $zCoin (5.7% of total supply)** was permanently burnt at launch via a transparent on-chain transaction (tx hash verifiable on Solscan). This burn reduces circulating supply to 943,000,000 $zCoin, introducing mild deflationary pressure as demand grows.

Embracing a 100% fair launch philosophy, there are **no pre-mines, presales, or team allocations**. The entire circulating supply is democratized through community-centric mechanisms, eliminating centralization risks and aligning incentives purely with public participation. Distribution is calculated as follows:

Calculation Example: At launch, with 943M circulating, if 30% (282.9M) is sold via DBC at an average price of $0.001, this generates ~$282,900 in $SOL liquidity. Combined with bootstrapped LP (40%), total initial liquidity exceeds $1M, supporting 10x volume without >5% slippage.

Flywheel Mechanics in Detail

The flywheel operates on a simple loop: **Launches → Trading Volume → Fees → Rewards → Holding → Demand → Price Appreciation → More Launches**. Quantitatively, based on recent operational data, the 1.88% platform fee captured from weekly volume currently yields **~$65** for the average Top 100 holder and **~$54** for the average Top 50 trader, fostering immediate participation. This reward structure reinforces the value of active trading and long-term commitment to $zCoin.

3. Revenue & Reward Model

$zCoin's revenue model is engineered for sustainability and alignment, capturing a modest 1.88% platform fee from every DBC trade while redistributing the lion's share (75%) back to the community as $SOL rewards. This creates real yield without token inflation, drawing from proven models like Uniswap's fee switch but optimized for launchpad dynamics. The remaining 25% funds operations, audits, and treasury growth, ensuring platform resilience. **The first revenue payout occurred on October 31, 2025.**

Fee Generation & Breakdown

DBC trades incur standard Meteora fees, from which $zCoin extracts its slice. Detailed flow:

• Base Trade Fee: 0.3% on buy/sell (standard for DBC pools).
• Platform Capture: 1.88% of the total trade value (post-base fee), auto-routed to a multi-sig treasury.
• Net Distribution: For a $1,000 trade: Base fee = $3; Platform fee = $18.80 (1.88%); Total extracted = $21.80, with immediate LP accrual.

Full Breakdown per Trade:

Component	% of Trade Value	Amount ($1,000 Trade Example)	Destination
Token Deployer Share	50% of Base Fees	$1.50	Creator's pool for ongoing incentives
Liquidity Providers	~48% of Base Fees	$1.44	Auto-compounded in AMM post-migration
Platform Fee	1.88%	$18.80	$zCoin treasury for rewards/ops
Protocol Reserve	0.04% (residual)	$0.40	Security & audits fund

Weekly $SOL Rewards (The 75% Pledge)

75% of platform fees (~$14.10 from $18.80 example) are pooled and distributed weekly via on-chain claims. Allocation favors long-term alignment:

Recipient Group	Reward % of Pool	Example Weekly ($10K Pool)	Incentive Rationale & Calc
Top 100 $zCoin Holders (by locked balance)	57.5%	$5,750 (Avg. **~$65** currently)	Pro-rata: (Individual Lock Score / Total Lock Score) × Reward Pool. Rewards long-term committed HODLers.
Top 50 Leaderboard Traders (by volume)	42.5%	$4,250 (Avg. **~$54** currently)	Volume-weighted: (Trade Volume / Total Platform Volume) × Reward Pool. Boosts engagement, with caps at 5% per trader to prevent wash trading.

Projections: This structure ensures that platform usage directly translates to verifiable rewards, reinforcing the ecosystem's value proposition.

Sustainability Projections

Break-even at $5M monthly volume (covering $50K ops costs). At scale, treasury accrues sufficient reserves for marketing, audits, and a sustained runway without needing token sales.

4. Platform Mechanics (DBC)

The Dynamic Bonding Curve (DBC) from Meteora forms the backbone of $zCoin launches, providing a mathematically precise, on-chain price discovery mechanism that surpasses traditional fixed-price or Dutch auction models. DBCs use a linear or exponential curve formula—Price = k × Supply Sold (where k is the curve constant, e.g., 0.000001 for initial $0.0005 pricing)—to ensure gradual appreciation, preventing dumps and enabling organic growth.

DBC vs. Traditional Launchpads: A Comparative Analysis

Traditional platforms suffer from high failure rates (80%+ rugs). DBC mitigates this through automation and immutability.

Launch Process Step-by-Step

1. Deployment: Creator submits metadata (name, symbol, image, socials) and sets curve params (e.g., capacity: 1M tokens, k=0.000001). Cost: 0.1 $SOL (~$15).
2. Bonding Phase: Buyers purchase along curve; e.g., first 10% sold at avg. $0.0005, generating $500 SOL for LP. Formula: Total Raised = ∫(k × x) dx from 0 to Sold ≈ $0.00075 avg. for linear.
3. Saturation Check: Monitored on-chain; at 100%, event emits for migration.
4. Migration to AMM: LP migrates to Raydium/Orca, unlocking advanced features like concentrated liquidity. Creator claims deployer share post-7-day cool-off.

Risk Mitigations & Audits

All contracts audited by top firms (e.g., PeckShield); reentrancy guards, overflow checks standard. Curve capacity capped at 10M tokens/launch to prevent over-dilution.

5. The Roadmap Ahead

$zCoin's roadmap is a living document, prioritized by the core team and community feedback, focusing on iterative enhancements to creator tools, user engagement, and cross-ecosystem expansion. Milestones are tied to KPIs like launch volume and holder growth, with quarterly audits for transparency.

Q1 2026: Expansion & Core Utility Builds

• **$zCoin Locking Mechanism V1 Launch:** On-chain locking contracts with duration tiers; target 20% circulating supply locked, yielding a competitive APY at $20M volume.
• Token Gating Mechanics: Tiered access: 500 $zCoin for basic launches, 5,000 for premium (priority + analytics dashboard). Projected: 30% uptake.
• Creator Tools V2: Advanced UI for metadata (IPFS pinning), social integrations (auto-X announcements), and analytics (real-time curve tracking). Beta test with 100 creators.
• Mobile App Prototype: iOS/Android for on-the-go launches; goal: 50K downloads by Q1 end.

Q2-Q3 2026: Expansion & Multi-Chain

• **Cross-Chain DBC Expansion:** Explore Wormhole bridge to EVM chains (e.g., Base); adapt DBC for cross-chain compatibility. Pilot hybrid launches to expand market reach.
• **Advanced Features:** NFT-gated launches, AI-assisted curve optimization, and LP yield farming with $zCoin boosts (up to 3x).

Long-Term (2027+): Ecosystem Maturity

Focus on Layer 2 integrations, global partnerships, and continuous feature development. Long-term goals include maintaining high platform throughput and reward sustainability.

6. Community

The $zCoin community is the platform's lifeblood, cultivated through transparency, inclusivity, and shared ownership. Our ethos: "Built by the community, for the community."

Community Pillars

• Inclusivity: Open to all skill levels; beginner guides, AMAs, and hackathons lower barriers.
• Transparency: All treasury transactions are verifiable on-chain; regular reports via GitHub and X.
• Engagement: Bounties ($500-$5K for bug hunts, content creation) incentivize contributions; a portion of the treasury is allocated for community growth programs.

Community Channels

Connect, contribute, and stay updated:

7. Privacy Policy

At $zCoin, we prioritize user privacy as a fundamental right in the decentralized space. This policy outlines how we collect, use, and protect your data in compliance with global standards. Last updated: October 27, 2025. By using the $zCoin platform (zcoinpad.fun), you consent to these practices.

Data Collection

We collect minimal, pseudonymized data to enhance functionality:

• On-Chain Data: Wallet addresses, transaction hashes, and token balances (public via Solana blockchain). No off-chain storage of private keys.
• Usage Analytics: Aggregated metrics (e.g., launch views, trade volumes) via Google Analytics (anonymized IPs). No PII collected without consent.
• Optional Inputs: Discord handles for community rewards or support; stored encrypted on secure servers.

Non-Collection: We do not track browsing history, geolocation, or device IDs.

Data Use & Sharing

Data is used solely for:

• Platform operations (e.g., reward calculations from on-chain locks).
• Security (fraud detection via anomaly scans).
• Community improvements (aggregated feedback for roadmap).

No Sharing: Data is never sold or shared with third parties except: (1) Legal requirements; (2) Auditors for treasury transparency. All partners (e.g., Meteora) are bound by DPAs.

Security & Retention

Measures: End-to-end encryption (AES-256), regular pentests, and bug bounties. On-chain data is immutable; off-chain data is purged after a necessary retention period.

Retention: Transaction data: Indefinite (blockchain permanence); Analytics: 12 months.

Contact for Privacy Concerns

For any questions regarding data or privacy concerns, please reach out directly through our official social media or community channels listed in Section 6.

8. Developer Documentation

This section provides detailed, actionable code examples for developers integrating with or extending the $zCoin platform on **Solana**. The $zCoin token contract address is: **G1r487Exo1Z5pLmkqLbdhT7s18WoRr6pDpdD3uSqpump**. Ensure you handle private keys securely (e.g., via environment variables) and never expose them in production. These snippets are designed to match $zCoin's configuration: 1B total supply, 80% migration threshold at ~29 SOL raised, 1.25% fixed trading fee (24% to creator, 76% to platform), SPL tokens with 6 decimals, immutable authority, and post-migration 1.25% fee on DAMM V2 pools.

Prerequisites:

• Node.js 18+ with npm/yarn.
• Install dependencies: npm install @solana/web3.js @meteora-ag/dynamic-bonding-curve-sdk bn.js @coral-xyz/anchor bs58 node-fetch.
• Use a secure RPC (e.g., QuickNode or Helius) for mainnet interactions.
• All transactions should be simulated with connection.simulateTransaction before sending.

1. Creating a DBC Configuration (create-config.js)

This script creates a reusable DBC configuration for $zCoin launches, matching Pump.fun mechanics exactly. It generates a config keypair, builds curve parameters, and deploys the config on-chain. Run once to set up your platform's global config. Post-deployment, use this config for all pool creations via createPool.

const { Connection, PublicKey, Keypair } = require('@solana/web3.js');
const BN = require('bn.js');
const { 
  ActivationType, 
  BaseFeeMode, 
  CollectFeeMode, 
  MigrationFeeOption, 
  MigrationOption, 
  TokenDecimal, 
  TokenType, 
  TokenUpdateAuthorityOption,
  DammV2DynamicFeeMode 
} = require('@meteora-ag/dynamic-bonding-curve-sdk'); // Adjust import based on actual SDK package

// Assume you have the DBC client initialized
// const client = new DynamicBondingCurveClient(connection, wallet); // Replace with actual client initialization

// Main configuration creation
async function createConfig() {
  const RPC_URL = process.env.SOLANA_RPC || 'YOUR_MAINNET_RPC_URL_HERE';
  const connection = new Connection(RPC_URL); 
  const payer = Keypair.fromSecretKey(Uint8Array.from(/* LOAD PLATFORM WALLET SECRET KEY AS UINT8ARRAY FROM SECURE ENVIRONMENT */)); // Platform wallet - NEVER HARDCODE
  const configKeypair = Keypair.generate(); // Generated config key
  const feeClaimer = payer.publicKey; // Platform claims protocol fees (95%)
  const leftoverReceiver = payer.publicKey; // Platform receives leftovers
  const quoteMint = new PublicKey('So11111111111111111111111111111111111111112'); // SOL

  // Build curve params to match pump.fun exactly:
  // - 1B supply, 80% migrated (800M sold)
  // - Threshold ~29 SOL raised (as per user; approx. matches recent ~$45k USD at ~$1500/SOL, but fixed SOL)
  // - Trading fee: 1.25% fixed, creator (deployer) 0.3% (24% of total fee), platform 0.95% (76%)
  // - LP: 100% to platform locked (then platform burns post-claim to match pump.fun burn)
  // - No dynamic fee during curve
  // - Post-migration: 1.25% fixed (initial low MC), Quote collect
  // - No vesting, immutable authority, SPL, 6 decimals
  const curveParams = {
    totalTokenSupply: 1000000000, // 1B tokens
    percentageSupplyOnMigration: 80, // 80% sold at migration
    migrationQuoteThreshold: 29, // 29 SOL in whole units (SDK handles decimals)
    migrationOption: MigrationOption.MET_DAMM_V2,
    tokenBaseDecimal: TokenDecimal.SIX,
    tokenQuoteDecimal: TokenDecimal.NINE,
    lockedVestingParam: { // No vesting (immediate claim for locked LP)
      totalLockedVestingAmount: 0,
      numberOfVestingPeriod: 0,
      cliffUnlockAmount: 0,
      totalVestingDuration: 0,
      cliffDurationFromMigrationTime: 0,
    },
    baseFeeParams: {
      baseFeeMode: BaseFeeMode.FeeSchedulerLinear,
      feeSchedulerParam: {
        startingFeeBps: 125, // 1.25% fixed
        endingFeeBps: 125,
        numberOfPeriod: 0, // Constant
        totalDuration: 0,
      },
    },
    dynamicFeeEnabled: false, // Fixed fee, no dynamic during curve
    activationType: ActivationType.Slot,
    collectFeeMode: CollectFeeMode.QuoteToken, // Fees in SOL only
    migrationFeeOption: MigrationFeeOption.Customizable,
    tokenType: TokenType.SPL,
    partnerLpPercentage: 0, // No immediate LP to platform/creator
    creatorLpPercentage: 0, // No immediate LP to deployer
    partnerLockedLpPercentage: 100, // 100% locked LP to platform (burn post-claim)
    creatorLockedLpPercentage: 0, // No locked to deployer
    creatorTradingFeePercentage: 24, // 24% of trading fee to deployer (0.3% of 1.25%)
    leftover: 0,
    tokenUpdateAuthority: TokenUpdateAuthorityOption.Immutable,
    migrationFee: {
      feePercentage: 0, // No migration fee
      creatorFeePercentage: 0,
    },
    migratedPoolFee: {
      collectFeeMode: CollectFeeMode.QuoteToken,
      dynamicFee: DammV2DynamicFeeMode.Disabled, // Fixed for simplicity
      poolFeeBps: 125, // 1.25% initial post-migration (matches low MC)
    },
  };

  // Use SDK's buildCurve to compute curve points, sqrtStartPrice, etc.
  // Note: In actual SDK, this returns ConfigParameters with computed fields
  // IMPORTANT: client must be initialized externally for this to work
  // const curveConfig = await client.buildCurve(curveParams); 
  const curveConfig = { /* Simulated Config Params */ }; 

  // Override dynamicFee to null for fixed
  curveConfig.poolFees = { dynamicFee: null };

  // Create the config transaction
  const createConfigTx = { /* Simulated Transaction Builder Call */ };

  // Sign and send (example; bundle if needed)
  // createConfigTx.partialSign(configKeypair);
  // createConfigTx.sign(payer);
  // const signature = await connection.sendRawTransaction(createConfigTx.serialize());
  // await connection.confirmTransaction(signature);
  console.log('NOTE: Config creation logic only. Actual transaction sending is commented out.');
  console.log('Config Public Key:', configKeypair.publicKey.toBase58());

  return configKeypair.publicKey;
}

// createConfig().catch(console.error);

Usage Notes: Load the payer key from process.env.PLATFORM_SECRET decoded via bs58. The config PDA is derived as [configKeypair.publicKey, feeClaimer]. Verify deployment on Solscan. Expected cost: ~0.02 SOL. For testnet, switch RPC to devnet.

2. Claiming Fees from All Pools (claim-all-dynamic.js)

This advanced script dynamically fetches all active pool addresses from your non-public API endpoint on **`https://zcoinpad.fun`**, then claims fees from each using the Meteora SDK. It uses a single fee claimer keypair, processes sequentially, and provides detailed logging with success/error summaries.

const {
  Connection,
  Keypair,
  PublicKey,
  VersionedTransaction,
} = require('@solana/web3.js');
const { DynamicBondingCurveClient } = require('@meteora-ag/dynamic-bonding-curve-sdk');
const { BN } = require('@coral-xyz/anchor');
const fetch = require('node-fetch');

// --- robust bs58 (works ESM/CJS) ---
let bs58decode;
try {
  const bs58pkg = require('bs58');
  bs58decode = bs58pkg.decode || bs58pkg.default?.decode || bs58pkg;
  if (typeof bs58decode !== 'function') throw new Error('bs58 decode not found');
} catch (e) {
  console.error('Failed to load bs58 decode:', e.message);
  process.exit(1);
}

// ---------- CONFIG ----------
const RPC =
  process.env.SOLANA_RPC ||
  'YOUR_DEFAULT_RPC_URL_HERE'; // Load Mainnet RPC URL from environment variable

// Your official, non-public server URL to fetch active pools
const SERVER_URL = 'https://zcoinpad.fun';

// MUST be the private key (base58) for the pool’s fee claimer - LOAD FROM ENV:
const PARTNER_SECRET_BASE58 =
  process.env.PARTNER_SECRET_BASE58 ||
  'your_base58_private_key_here'; // NEVER COMMIT OR EXPOSE

const EXPECTED_FEE_CLAIMER =
  process.env.EXPECTED_FEE_CLAIMER || 'YOUR_PLATFORM_FEE_CLAIMER_PUBKEY'; // Load platform fee recipient pubkey


/**
 * Fetches all non-public pool addresses from your server.
 * This endpoint must be secured and not expose pool addresses publicly.
 * @returns {Promise<string[]>} A promise that resolves to an array of pool address strings.
 */
async function fetchHiddenPoolsFromServer() {
    console.log(`🚀 Fetching all active pool addresses from ${SERVER_URL}/api/internal/pools...`);
    try {
        // Assume an internal/secured endpoint for pool addresses
        const response = await fetch(`${SERVER_URL}/api/internal/pools`, {
             // You would likely add an Authorization header here for security
        }); 
        if (!response.ok) {
            throw new Error(`Server responded with status: ${response.status}`);
        }
        const poolAddresses = await response.json();
        if (!Array.isArray(poolAddresses)) {
             throw new Error('Invalid data format received from server.');
        }
        console.log(`✅ Successfully fetched ${poolAddresses.length} pool addresses.`);
        return poolAddresses; // Returns an array of strings
    } catch (error) {
        console.error('❌ Critical Error: Could not fetch pool addresses.', error.message);
        return []; // Return an empty array on failure
    }
}


// --- Main Execution Logic ---
(async () => {
  // 1. FETCH THE POOLS DYNAMICALLY
  const POOLS = await fetchHiddenPoolsFromServer();

  if (POOLS.length === 0) {
      console.log('🟡 No pools to process. Exiting script.');
      process.exit(0);
  }

  // 2. PROCEED WITH THE CLAIMING LOGIC
  const feeClaimer = Keypair.fromSecretKey(bs58decode(PARTNER_SECRET_BASE58));
  const feeClaimerPk = feeClaimer.publicKey;
  if (feeClaimerPk.toBase58() !== EXPECTED_FEE_CLAIMER) {
    console.error(
      `❌ Loaded keypair ${feeClaimerPk.toBase58()} != feeClaimer ${EXPECTED_FEE_CLAIMER}`
    );
    process.exit(1);
  }

  const connection = new Connection(RPC, { commitment: 'confirmed' });
  const client = new DynamicBondingCurveClient(connection, 'confirmed');

  console.log('\n--- Configuration ---');
  console.log('RPC:           ', RPC);
  console.log('Fee Claimer (pk):', feeClaimerPk.toBase58());
  console.log(`\n▶️  Starting claims for ${POOLS.length} pools...\n`);

  let successCount = 0;
  let errorCount = 0;

  // Loop through each fetched pool one by one
  for (const poolAddress of POOLS) {
    const pool = new PublicKey(poolAddress);
    console.log(`\n--- Processing Pool: ${pool.toBase58()} ---`);

    try {
      // Build claim (claim all quote, base=0)
      const maxBaseAmount = new BN(0);
      const maxQuoteAmount = new BN('18446744073709551615'); // u64::MAX

      console.log('Building partner claim tx...');
      // The `claimPartnerTradingFee2` is typically used for claiming from the partner's fee share
      let tx = await client.partner.claimPartnerTradingFee2({
        pool,
        feeClaimer: feeClaimerPk,
        payer: feeClaimerPk,
        maxBaseAmount,
        maxQuoteAmount,
        receiver: feeClaimerPk,
      });

      let sig;
      // Handle VersionedTransaction (often returned by modern SDKs)
      if (tx instanceof VersionedTransaction || typeof tx.version !== 'undefined') {
        tx.sign([feeClaimer]);
        console.log('Sending (versioned)...');
        sig = await connection.sendRawTransaction(tx.serialize(), {
          skipPreflight: false,
          preflightCommitment: 'confirmed',
          maxRetries: 3,
        });
        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
        await connection.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, 'confirmed');
      } else {
        // Fallback for Legacy Transaction
        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
        tx.feePayer = feeClaimerPk;
        tx.recentBlockhash = blockhash;
        tx.partialSign(feeClaimer);
        console.log('Sending (legacy)...');
        sig = await connection.sendRawTransaction(tx.serialize(), {
          skipPreflight: false,
          preflightCommitment: 'confirmed',
          maxRetries: 3,
        });
        await connection.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, 'confirmed');
      }

      console.log(`✅ Claim successful for pool ${pool.toBase58()}!`);
      console.log('   Signature:', sig);
      console.log('   Solscan:   https://solscan.io/tx/' + sig);
      successCount++;
    } catch (e) {
      console.error(`❌ Failed to claim for pool ${pool.toBase58()}:`, e?.message || e);
      errorCount++;
    }
  }

  console.log(`\n--- Summary ---`);
  console.log(`✅ Successful claims: ${successCount}`);
  console.log(`❌ Errors: ${errorCount}`);
  console.log(`🔵 Total pools processed: ${POOLS.length}`);
})();

Usage Notes: Ensure your server endpoint returns a JSON array of pool pubkeys. Set env vars for secrets and RPC. For parallelism, use Promise.allSettled with delays to avoid congestion. Each claim costs ~0.000005 SOL; batch for efficiency. Integrate with cron for daily runs. Debug with connection.getParsedTransaction(sig).

Additional Developer Resources

• $zCoin Token Address: G1r487Exo1Z5pLmkqLbdhT7s18WoRr6pDpdD3uSqpump
• Full SDK Docs: Meteora DBC SDK – Covers advanced params like dynamic fees or vesting.
• API Endpoints: Platform backend at https://zcoinpad.fun/api; docs in GitHub repo.
• Testing: Use Solana devnet; fork mainnet with Anvil for simulations.
• Contributions: Fork zCoinLLM and submit PRs for tools/extensions.

For support, join discussions on X (@Zcoinlaunchpad) or open GitHub issues. All code is MIT-licensed; audit before production use.