Add bonding curve swap, bucket fetch, and registration flags (#109)

* Update genesis SDK to v0.34.0 for devnet API compatibility

The devnet API now expects updated bonding curve constants (new supply/virtual
token ratios). SDK 0.32.1 payloads were rejected with validation errors.

* Add bonding curve swap command, bucket fetch, and registration flags

- New `genesis swap` command for buying/selling on bonding curves
  with --info mode for price quotes and curve status
- Add bonding curve bucket type to `genesis bucket fetch`
  with pricing, reserves, and status display
- Add --creatorWallet and --twitterVerificationToken flags
  to `genesis launch create` and `genesis launch register`
- Tests for all new features (12 new test cases)

* align parameters

* Address CodeRabbit review feedback

- Use lamports() instead of sol(Number/1e9) to preserve precision
- Add BigInt validation with clear errors in --info quote mode
- Remove unused stripAnsi import in tests

* Fix lint errors in genesis swap, bucket fetch, and launch commands

Resolve ESLint errors including import/object/class member sorting,
padding lines, prefer-switch, Number.isNaN, Boolean coercion,
destructuring, and promise executor return issues.

https://claude.ai/code/session_01LNfYbSi7Vkp8c6w6T3zLu8

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: MarkSackerberg

src/commands/genesis/bucket/fetch.ts

@@ -1,10 +1,19 @@
 import {
-  safeFetchGenesisAccountV2,
+  findBondingCurveBucketV2Pda,
   findLaunchPoolBucketV2Pda,
-  safeFetchLaunchPoolBucketV2,
   findPresaleBucketV2Pda,
-  safeFetchPresaleBucketV2,
   findUnlockedBucketV2Pda,
+  getCurrentPrice,
+  getCurrentPriceComponents,
+  getCurrentPriceQuotePerBase,
+  getFillPercentage,
+  isFirstBuyPending,
+  isSoldOut,
+  isSwappable,
+  safeFetchBondingCurveBucketV2,
+  safeFetchGenesisAccountV2,
+  safeFetchLaunchPoolBucketV2,
+  safeFetchPresaleBucketV2,
   safeFetchUnlockedBucketV2,
 } from '@metaplex-foundation/genesis'
 import { publicKey } from '@metaplex-foundation/umi'
@@ -21,44 +30,49 @@ function formatCondition(condition: { __kind: string; time?: bigint }): string {
     if (timestamp === 0) return 'Not set'
     return new Date(timestamp * 1000).toISOString()
   }
+
   return `${condition.__kind}`
 }
 
 export default class BucketFetch extends BaseCommand<typeof BucketFetch> {
-  static override description = `Fetch a Genesis bucket by genesis address and bucket index.
-
-This command retrieves and displays information about a bucket in a Genesis account.
-Supports Launch Pool, Presale, and Unlocked bucket types.`
-
-  static override examples = [
-    '$ mplx genesis bucket fetch GenesisAddress... --bucketIndex 0',
-    '$ mplx genesis bucket fetch GenesisAddress... -b 1 --type presale',
-    '$ mplx genesis bucket fetch GenesisAddress... -b 2 --type unlocked',
-  ]
-
-  static override usage = 'genesis bucket fetch [GENESIS] [FLAGS]'
-
   static override args = {
     genesis: Args.string({
       description: 'The Genesis account address',
       required: true,
     }),
   }
 
+  static override description = `Fetch a Genesis bucket by genesis address and bucket index.
+
+This command retrieves and displays information about a bucket in a Genesis account.
+Supports Launch Pool, Presale, Unlocked, and Bonding Curve bucket types.
+
+When --type is not specified, the command auto-detects the bucket type by trying
+all known types at the given index.`
+
+  static override examples = [
+    '$ mplx genesis bucket fetch GenesisAddress...',
+    '$ mplx genesis bucket fetch GenesisAddress... -b 1',
+    '$ mplx genesis bucket fetch GenesisAddress... --type presale -b 0',
+    '$ mplx genesis bucket fetch GenesisAddress... --type bonding-curve',
+  ]
+
   static override flags = {
     bucketIndex: Flags.integer({
       char: 'b',
-      description: 'Index of the bucket to fetch',
       default: 0,
+      description: 'Index of the bucket to fetch',
     }),
     type: Flags.option({
       char: 't',
-      description: 'Type of bucket to fetch',
-      default: 'launch-pool',
-      options: ['launch-pool', 'presale', 'unlocked'] as const,
+      description: 'Type of bucket to fetch (auto-detected if not specified)',
+      options: ['launch-pool', 'presale', 'unlocked', 'bonding-curve'] as const,
+      required: false,
     })(),
   }
 
+  static override usage = 'genesis bucket fetch [GENESIS] [FLAGS]'
+
   public async run(): Promise<unknown> {
     const { args, flags } = await this.parse(BucketFetch)
     const spinner = ora('Fetching bucket...').start()
@@ -77,24 +91,170 @@ Supports Launch Pool, Presale, and Unlocked bucket types.`
 
       spinner.text = 'Fetching bucket details...'
 
-      if (flags.type === 'presale') {
-        return await this.fetchPresaleBucket(genesisAddress, flags.bucketIndex, spinner)
-      } else if (flags.type === 'unlocked') {
-        return await this.fetchUnlockedBucket(genesisAddress, flags.bucketIndex, spinner)
-      } else {
-        return await this.fetchLaunchPoolBucket(genesisAddress, flags.bucketIndex, spinner)
+      if (flags.type) {
+        // Explicit type specified
+        if (flags.type === 'presale') {
+          return await this.fetchPresaleBucket(genesisAddress, flags.bucketIndex, spinner)
+        }
+
+ if (flags.type === 'unlocked') {
+          return await this.fetchUnlockedBucket(genesisAddress, flags.bucketIndex, spinner)
+        }
+
+ if (flags.type === 'bonding-curve') {
+          return await this.fetchBondingCurveBucket(genesisAddress, flags.bucketIndex, spinner)
+        }
+ 
+          return await this.fetchLaunchPoolBucket(genesisAddress, flags.bucketIndex, spinner)
+        
       }
 
+      // Auto-detect: try all bucket types at this index
+      spinner.text = 'Detecting bucket type...'
+      return await this.fetchAutoDetect(genesisAddress, flags.bucketIndex, spinner)
+
     } catch (error) {
       spinner.fail('Failed to fetch bucket')
       throw error
     }
   }
 
+  private async fetchAutoDetect(genesisAddress: ReturnType<typeof publicKey>, bucketIndex: number, spinner: ReturnType<typeof ora>): Promise<unknown> {
+    // Probe all bucket types at this index in parallel
+    const [bc, lp, pre, ul] = await Promise.all([
+      safeFetchBondingCurveBucketV2(this.context.umi, findBondingCurveBucketV2Pda(this.context.umi, { bucketIndex, genesisAccount: genesisAddress })[0]),
+      safeFetchLaunchPoolBucketV2(this.context.umi, findLaunchPoolBucketV2Pda(this.context.umi, { bucketIndex, genesisAccount: genesisAddress })[0]),
+      safeFetchPresaleBucketV2(this.context.umi, findPresaleBucketV2Pda(this.context.umi, { bucketIndex, genesisAccount: genesisAddress })[0]),
+      safeFetchUnlockedBucketV2(this.context.umi, findUnlockedBucketV2Pda(this.context.umi, { bucketIndex, genesisAccount: genesisAddress })[0]),
+    ])
+
+    const found: { fn: () => Promise<unknown>; type: string }[] = []
+    if (bc) found.push({ fn: () => this.fetchBondingCurveBucket(genesisAddress, bucketIndex, spinner), type: 'bonding-curve' })
+    if (lp) found.push({ fn: () => this.fetchLaunchPoolBucket(genesisAddress, bucketIndex, spinner), type: 'launch-pool' })
+    if (pre) found.push({ fn: () => this.fetchPresaleBucket(genesisAddress, bucketIndex, spinner), type: 'presale' })
+    if (ul) found.push({ fn: () => this.fetchUnlockedBucket(genesisAddress, bucketIndex, spinner), type: 'unlocked' })
+
+    if (found.length === 0) {
+      spinner.fail('Bucket not found')
+      this.error(`No bucket found at index ${bucketIndex}. Tried all bucket types (launch-pool, presale, unlocked, bonding-curve).`)
+    }
+
+    if (found.length === 1) {
+      return found[0].fn()
+    }
+
+    // Multiple bucket types at the same index — show all
+    spinner.succeed(`Found ${found.length} buckets at index ${bucketIndex}`)
+    const results: unknown[] = await Promise.all(found.map(async ({ fn }) => {
+      const result = await fn()
+      this.log('')
+      return result
+    }))
+
+    return results
+  }
+
+  private async fetchBondingCurveBucket(genesisAddress: ReturnType<typeof publicKey>, bucketIndex: number, spinner: ReturnType<typeof ora>): Promise<unknown> {
+    const [bucketPda] = findBondingCurveBucketV2Pda(this.context.umi, {
+      bucketIndex,
+      genesisAccount: genesisAddress,
+    })
+
+    const bucket = await safeFetchBondingCurveBucketV2(this.context.umi, bucketPda)
+
+    if (!bucket) {
+      spinner.fail('Bucket not found')
+      this.error(`Bonding curve bucket not found at index ${bucketIndex}. It may be a different bucket type or not exist.`)
+    }
+
+    spinner.succeed('Bucket fetched successfully!')
+
+    const price = getCurrentPrice(bucket)
+    const priceQuotePerBase = getCurrentPriceQuotePerBase(bucket)
+    const { baseReserves, quoteReserves } = getCurrentPriceComponents(bucket)
+    const firstBuyPending = isFirstBuyPending(bucket)
+    const swappable = isSwappable(bucket)
+    const soldOut = isSoldOut(bucket)
+    const fillPct = getFillPercentage(bucket)
+
+    this.log('')
+    this.logSuccess(`Bonding Curve Bucket`)
+    this.log('')
+    this.log('Bucket Details:')
+    this.log(`  Address: ${bucketPda}`)
+    this.log(`  Type: ${KEY_TYPES[bucket.key] || 'BondingCurveV2'}`)
+    this.log(`  Genesis Account: ${bucket.bucket.genesis}`)
+    this.log(`  Bucket Index: ${bucket.bucket.bucketIndex}`)
+    this.log('')
+    this.log('Allocation:')
+    this.log(`  Base Token Allocation: ${bucket.bucket.baseTokenAllocation.toString()}`)
+    this.log(`  Base Token Balance: ${bucket.bucket.baseTokenBalance.toString()}`)
+    this.log(`  Quote Token Deposit Total: ${bucket.quoteTokenDepositTotal.toString()}`)
+    this.log('')
+    this.log('Pricing:')
+    this.log(`  Current Price (tokens per quote): ${price.toString()}`)
+    this.log(`  Current Price (quote per token): ${priceQuotePerBase.toString()}`)
+    this.log(`  Base Reserves: ${baseReserves.toString()}`)
+    this.log(`  Quote Reserves: ${quoteReserves.toString()}`)
+    this.log('')
+    this.log('Constant Product Params:')
+    this.log(`  Virtual SOL: ${bucket.constantProductParams.virtualSol.toString()}`)
+    this.log(`  Virtual Tokens: ${bucket.constantProductParams.virtualTokens.toString()}`)
+    this.log('')
+    this.log('Status:')
+    this.log(`  First Buy Pending: ${firstBuyPending ? 'Yes' : 'No'}`)
+    this.log(`  Swappable: ${swappable ? 'Yes' : 'No'}`)
+    this.log(`  Sold Out: ${soldOut ? 'Yes' : 'No'}`)
+    this.log(`  Fill Percentage: ${fillPct.toFixed(2)}%`)
+    this.log('')
+    this.log('Conditions:')
+    this.log(`  Swap Start: ${formatCondition(bucket.swapStartCondition)}`)
+    this.log(`  Swap End: ${formatCondition(bucket.swapEndCondition)}`)
+    this.log('')
+    this.log('Fees:')
+    this.log(`  Deposit Fee: ${bucket.depositFee.toString()}`)
+    this.log(`  Withdraw Fee: ${bucket.withdrawFee.toString()}`)
+    this.log(`  Creator Fee Accrued: ${bucket.creatorFeeAccrued.toString()}`)
+    this.log(`  Creator Fee Claimed: ${bucket.creatorFeeClaimed.toString()}`)
+    this.log('')
+    this.log('View on Explorer:')
+    this.log(
+      generateExplorerUrl(
+        this.context.explorer,
+        this.context.chain,
+        bucketPda,
+        'account'
+      )
+    )
+
+    return {
+      address: bucketPda.toString(),
+      baseReserves: baseReserves.toString(),
+      baseTokenAllocation: bucket.bucket.baseTokenAllocation.toString(),
+      baseTokenBalance: bucket.bucket.baseTokenBalance.toString(),
+      bucketIndex: bucket.bucket.bucketIndex,
+      creatorFeeAccrued: bucket.creatorFeeAccrued.toString(),
+      creatorFeeClaimed: bucket.creatorFeeClaimed.toString(),
+      currentPrice: price.toString(),
+      currentPriceQuotePerBase: priceQuotePerBase.toString(),
+      explorer: generateExplorerUrl(this.context.explorer, this.context.chain, bucketPda, 'account'),
+      fillPercentage: fillPct,
+      firstBuyPending,
+      genesisAccount: bucket.bucket.genesis.toString(),
+      quoteReserves: quoteReserves.toString(),
+      quoteTokenDepositTotal: bucket.quoteTokenDepositTotal.toString(),
+      soldOut,
+      swappable,
+      type: 'bonding-curve',
+      virtualSol: bucket.constantProductParams.virtualSol.toString(),
+      virtualTokens: bucket.constantProductParams.virtualTokens.toString(),
+    }
+  }
+
   private async fetchLaunchPoolBucket(genesisAddress: ReturnType<typeof publicKey>, bucketIndex: number, spinner: ReturnType<typeof ora>): Promise<unknown> {
     const [bucketPda] = findLaunchPoolBucketV2Pda(this.context.umi, {
-      genesisAccount: genesisAddress,
       bucketIndex,
+      genesisAccount: genesisAddress,
     })
 
     const bucket = await safeFetchLaunchPoolBucketV2(this.context.umi, bucketPda)
@@ -149,20 +309,20 @@ Supports Launch Pool, Presale, and Unlocked bucket types.`
     )
 
     return {
-      type: 'launch-pool',
       address: bucketPda.toString(),
-      genesisAccount: bucket.bucket.genesis.toString(),
-      bucketIndex: bucket.bucket.bucketIndex,
       baseTokenAllocation: bucket.bucket.baseTokenAllocation.toString(),
       baseTokenBalance: bucket.bucket.baseTokenBalance.toString(),
+      bucketIndex: bucket.bucket.bucketIndex,
       explorer: generateExplorerUrl(this.context.explorer, this.context.chain, bucketPda, 'account'),
+      genesisAccount: bucket.bucket.genesis.toString(),
+      type: 'launch-pool',
     }
   }
 
   private async fetchPresaleBucket(genesisAddress: ReturnType<typeof publicKey>, bucketIndex: number, spinner: ReturnType<typeof ora>): Promise<unknown> {
     const [bucketPda] = findPresaleBucketV2Pda(this.context.umi, {
-      genesisAccount: genesisAddress,
       bucketIndex,
+      genesisAccount: genesisAddress,
     })
 
     const bucket = await safeFetchPresaleBucketV2(this.context.umi, bucketPda)
@@ -216,21 +376,21 @@ Supports Launch Pool, Presale, and Unlocked bucket types.`
     )
 
     return {
-      type: 'presale',
       address: bucketPda.toString(),
-      genesisAccount: bucket.bucket.genesis.toString(),
-      bucketIndex: bucket.bucket.bucketIndex,
+      allocationQuoteTokenCap: bucket.allocationQuoteTokenCap.toString(),
       baseTokenAllocation: bucket.bucket.baseTokenAllocation.toString(),
       baseTokenBalance: bucket.bucket.baseTokenBalance.toString(),
-      allocationQuoteTokenCap: bucket.allocationQuoteTokenCap.toString(),
+      bucketIndex: bucket.bucket.bucketIndex,
       explorer: generateExplorerUrl(this.context.explorer, this.context.chain, bucketPda, 'account'),
+      genesisAccount: bucket.bucket.genesis.toString(),
+      type: 'presale',
     }
   }
 
   private async fetchUnlockedBucket(genesisAddress: ReturnType<typeof publicKey>, bucketIndex: number, spinner: ReturnType<typeof ora>): Promise<unknown> {
     const [bucketPda] = findUnlockedBucketV2Pda(this.context.umi, {
-      genesisAccount: genesisAddress,
       bucketIndex,
+      genesisAccount: genesisAddress,
     })
 
     const bucket = await safeFetchUnlockedBucketV2(this.context.umi, bucketPda)
@@ -274,15 +434,15 @@ Supports Launch Pool, Presale, and Unlocked bucket types.`
     )
 
     return {
-      type: 'unlocked',
       address: bucketPda.toString(),
-      genesisAccount: bucket.bucket.genesis.toString(),
-      bucketIndex: bucket.bucket.bucketIndex,
       baseTokenAllocation: bucket.bucket.baseTokenAllocation.toString(),
       baseTokenBalance: bucket.bucket.baseTokenBalance.toString(),
-      recipient: bucket.recipient.toString(),
+      bucketIndex: bucket.bucket.bucketIndex,
       claimed: bucket.claimed,
       explorer: generateExplorerUrl(this.context.explorer, this.context.chain, bucketPda, 'account'),
+      genesisAccount: bucket.bucket.genesis.toString(),
+      recipient: bucket.recipient.toString(),
+      type: 'unlocked',
     }
   }
 }

src/commands/genesis/index.ts

@@ -9,6 +9,8 @@ export default class Genesis extends Command {
     '<%= config.bin %> genesis deposit GenesisAddress123... --amount 1000',
     '<%= config.bin %> genesis claim GenesisAddress123...',
     '<%= config.bin %> genesis finalize GenesisAddress123...',
+    '<%= config.bin %> genesis swap GenesisAddress123... --direction buy --amount 100000000',
+    '<%= config.bin %> genesis swap GenesisAddress123... --info',
   ]
 
   public async run(): Promise<void> {
@@ -23,6 +25,7 @@ export default class Genesis extends Command {
     this.log('  genesis withdraw       Withdraw from a launch pool')
     this.log('  genesis claim          Claim tokens from a completed launch')
     this.log('  genesis claim-unlocked Claim tokens from an unlocked bucket')
+    this.log('  genesis swap           Buy/sell on a bonding curve (also: --info for status & quotes)')
     this.log('  genesis transition     Execute end behaviors for a bucket')
     this.log('  genesis finalize       Finalize a Genesis launch')
     this.log('  genesis revoke         Revoke/cancel a Genesis launch')