naracli 0.1.0

package/src/client.ts

@@ -0,0 +1,96 @@
+import {
+  Connection,
+  PublicKey,
+  Transaction,
+  AddressLookupTableAccount,
+  MessageV0,
+  VersionedTransaction,
+} from "@solana/web3.js";
+import { DynamicBondingCurveClient } from "@meteora-ag/dynamic-bonding-curve-sdk";
+
+export interface NaraSDKConfig {
+  rpcUrl: string;
+  commitment?: "processed" | "confirmed" | "finalized";
+  /** Address Lookup Table addresses array for compressing transaction size */
+  addressLookupTableAddresses?: string[];
+}
+
+export class NaraSDK {
+  private connection: Connection;
+  private client: DynamicBondingCurveClient;
+  private addressLookupTableAddresses: PublicKey[];
+
+  constructor(config: NaraSDKConfig) {
+    this.connection = new Connection(
+      config.rpcUrl,
+      config.commitment || "confirmed"
+    );
+    this.client = new DynamicBondingCurveClient(
+      this.connection,
+      config.commitment || "confirmed"
+    );
+    this.addressLookupTableAddresses = (
+      config.addressLookupTableAddresses || []
+    ).map((addr) => new PublicKey(addr));
+  }
+
+  getConnection(): Connection {
+    return this.connection;
+  }
+
+  getClient(): DynamicBondingCurveClient {
+    return this.client;
+  }
+
+  getAddressLookupTableAddresses(): PublicKey[] {
+    return this.addressLookupTableAddresses;
+  }
+
+  /**
+   * Compile transaction with Address Lookup Tables
+   * Converts Transaction to VersionedTransaction if ALT is configured
+   * @param transaction Original transaction
+   * @param feePayer Fee payer public key
+   * @returns VersionedTransaction or original Transaction
+   */
+  async compileTransactionWithALT(
+    transaction: Transaction,
+    feePayer: PublicKey
+  ): Promise<Transaction | VersionedTransaction> {
+    if (this.addressLookupTableAddresses.length === 0) {
+      // No ALT configured, return original transaction
+      return transaction;
+    }
+
+    // Fetch Address Lookup Table accounts
+    const lookupTableAccounts: AddressLookupTableAccount[] = [];
+    for (const address of this.addressLookupTableAddresses) {
+      const accountInfo =
+        await this.connection.getAddressLookupTable(address);
+      if (accountInfo.value) {
+        lookupTableAccounts.push(accountInfo.value);
+      }
+    }
+
+    if (lookupTableAccounts.length === 0) {
+      // No valid ALT accounts, return original transaction
+      return transaction;
+    }
+
+    // Get latest blockhash
+    const { blockhash } = await this.connection.getLatestBlockhash(
+      this.connection.commitment
+    );
+
+    // Create MessageV0
+    const messageV0 = MessageV0.compile({
+      payerKey: feePayer,
+      instructions: transaction.instructions,
+      recentBlockhash: blockhash,
+      addressLookupTableAccounts: lookupTableAccounts,
+    });
+
+    // Create VersionedTransaction
+    return new VersionedTransaction(messageV0);
+  }
+}

package/src/config.ts

@@ -0,0 +1,132 @@
+import { Keypair, PublicKey, Transaction } from "@solana/web3.js";
+import {
+  buildCurveWithMarketCap,
+  ActivationType,
+  CollectFeeMode,
+  BaseFeeMode,
+  MigrationFeeOption,
+  MigrationOption,
+  TokenDecimal,
+  TokenType,
+  TokenUpdateAuthorityOption,
+} from "@meteora-ag/dynamic-bonding-curve-sdk";
+import { NATIVE_MINT } from "@solana/spl-token";
+import { NaraSDK } from "./client";
+
+/**
+ * Options for creating configuration
+ */
+export interface CreateConfigOptions {
+  /** Fee claimer wallet address */
+  feeClaimer: PublicKey;
+  /** Leftover token receiver wallet address */
+  leftoverReceiver: PublicKey;
+  /** Payer wallet address */
+  payer: PublicKey;
+  // Curve parameters (all optional with defaults)
+  /** Total token supply (default: 1,000,000,000) */
+  totalTokenSupply?: number;
+  /** Initial market cap (default: 30) */
+  initialMarketCap?: number;
+  /** Migration market cap threshold (default: 540) */
+  migrationMarketCap?: number;
+}
+
+/**
+ * Return type for bonding curve config transaction creation
+ */
+export interface CreateConfigResult {
+  /** Config address */
+  configAddress: string;
+  /** Unsigned transaction */
+  transaction: Transaction;
+  /** Config keypair (requires partial signature) */
+  configKeypair: Keypair;
+}
+
+/**
+ * Create bonding curve config transaction (returns unsigned transaction)
+ * @param sdk NaraSDK SDK instance
+ * @param options Configuration options
+ * @returns Config address, unsigned transaction, and config keypair
+ */
+export async function createConfig(
+  sdk: NaraSDK,
+  options: CreateConfigOptions
+): Promise<CreateConfigResult> {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+
+  // Generate new config keypair
+  const config = Keypair.generate();
+
+  // Build bonding curve configuration
+  const curveConfig = buildCurveWithMarketCap({
+    totalTokenSupply: options.totalTokenSupply ?? 1_000_000_000, // Total token supply
+    initialMarketCap: options.initialMarketCap ?? 30, // Initial market cap
+    migrationMarketCap: options.migrationMarketCap ?? 540, // Migration market cap threshold
+    migrationOption: MigrationOption.MET_DAMM_V2, // Migration option: use Meteora DAMM V2
+    tokenBaseDecimal: TokenDecimal.SIX, // Base token decimals: 6
+    tokenQuoteDecimal: TokenDecimal.NINE, // Quote token decimals: 9 (SOL)
+    // Locked vesting parameters
+    lockedVestingParams: {
+      totalLockedVestingAmount: 0, // Total locked vesting amount
+      numberOfVestingPeriod: 0, // Number of vesting periods
+      cliffUnlockAmount: 0, // Cliff unlock amount
+      totalVestingDuration: 0, // Total vesting duration
+      cliffDurationFromMigrationTime: 0, // Cliff duration from migration time
+    },
+    // Base fee parameters
+    baseFeeParams: {
+      baseFeeMode: BaseFeeMode.FeeSchedulerLinear, // Fee mode: linear scheduler
+      feeSchedulerParam: {
+        startingFeeBps: 100, // Starting fee (basis points): 1%
+        endingFeeBps: 100, // Ending fee (basis points): 1%
+        numberOfPeriod: 0, // Number of periods
+        totalDuration: 0, // Total duration
+      },
+    },
+    dynamicFeeEnabled: true, // Enable dynamic fees
+    activationType: ActivationType.Slot, // Activation type: slot-based
+    collectFeeMode: CollectFeeMode.QuoteToken, // Fee collection mode: quote token
+    migrationFeeOption: MigrationFeeOption.FixedBps25, // Migration fee option: fixed 1%
+    tokenType: TokenType.SPL, // Token type: SPL token
+    partnerLiquidityPercentage: 0, // Partner liquidity percentage
+    creatorLiquidityPercentage: 0, // Creator liquidity percentage
+    partnerPermanentLockedLiquidityPercentage: 100, // Partner permanent locked liquidity: 100%
+    creatorPermanentLockedLiquidityPercentage: 0, // Creator permanent locked liquidity: 0%
+    creatorTradingFeePercentage: 0, // Creator trading fee percentage: 0%
+    leftover: 0, // Leftover token amount
+    tokenUpdateAuthority: TokenUpdateAuthorityOption.Immutable, // Token update authority: immutable
+    // Migration fee
+    migrationFee: {
+      feePercentage: 0, // Fee percentage
+      creatorFeePercentage: 0, // Creator fee percentage
+    },
+    poolCreationFee: 0.1, // Pool creation fee
+    enableFirstSwapWithMinFee: true, // Enable first swap with minimum fee
+  });
+
+  // Create config transaction
+  const transaction = await client.partner.createConfig({
+    config: config.publicKey, // Config public key
+    feeClaimer: options.feeClaimer, // Fee claimer
+    leftoverReceiver: options.leftoverReceiver, // Leftover receiver
+    payer: options.payer, // Payer
+    quoteMint: NATIVE_MINT, // Quote mint: native SOL
+    ...curveConfig, // Curve config parameters
+  });
+
+  // Get latest blockhash
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  transaction.recentBlockhash = blockhash;
+  transaction.feePayer = options.payer;
+  // Config account partial signature
+  transaction.partialSign(config);
+
+  return {
+    configAddress: config.publicKey.toBase58(), // Config address
+    transaction, // Unsigned transaction (already has config's partial signature)
+    configKeypair: config, // Config keypair
+  };
+}

package/src/constants.ts

@@ -0,0 +1,29 @@
+/**
+ * SDK and CLI default constants
+ *
+ * Priority for all values: CLI flag > env variable > default value
+ */
+
+/**
+ * Default RPC URL for Nara testnet
+ */
+export const DEFAULT_RPC_URL =
+  process.env.RPC_URL || "https://mainnet-api.nara.build/";
+
+/**
+ * Default bonding curve config address
+ */
+export const DEFAULT_DBC_CONFIG_ADDRESS =
+  process.env.DBC_CONFIG_ADDRESS || "";
+
+/**
+ * Default wallet path
+ */
+export const DEFAULT_WALLET_PATH =
+  process.env.WALLET_PATH || "~/.config/nara/id.json";
+
+/**
+ * Default quest relay URL
+ */
+export const DEFAULT_QUEST_RELAY_URL =
+  process.env.QUEST_RELAY_URL || "https://quest-api.nara.build/";

package/src/migrate.ts

@@ -0,0 +1,222 @@
+import {
+  PublicKey,
+  Transaction,
+  Keypair,
+  VersionedTransaction,
+} from "@solana/web3.js";
+import BN from "bn.js";
+import { NaraSDK } from "./client";
+import { DAMM_V2_MIGRATION_FEE_ADDRESS } from "@meteora-ag/dynamic-bonding-curve-sdk";
+
+export interface MigrateToDAMMV2Params {
+  /** Token address (baseMint) */
+  tokenAddress: string;
+  /** Payer */
+  payer: PublicKey;
+}
+
+export interface MigrateToDAMMV2Result {
+  /** Migration transaction (returns VersionedTransaction if ALT is configured) */
+  transaction: Transaction | VersionedTransaction;
+  /** First Position NFT keypair (requires signature) */
+  firstPositionNftKeypair: Keypair;
+  /** Second Position NFT keypair (requires signature) */
+  secondPositionNftKeypair: Keypair;
+  /** Pool address */
+  poolAddress: string;
+}
+
+export interface CreateLockerParams {
+  /** Token address (baseMint) */
+  tokenAddress: string;
+  /** Payer */
+  payer: PublicKey;
+}
+
+export interface CreateLockerResult {
+  /** Locker creation transaction (returns VersionedTransaction if ALT is configured) */
+  transaction: Transaction | VersionedTransaction;
+  /** Pool address */
+  poolAddress: string;
+}
+
+/**
+ * Launch token pool to DAMM V2 (graduation)
+ *
+ * Call this function to migrate the pool to DAMM V2 after the bonding curve is complete (100%)
+ *
+ * Notes:
+ * - dammConfig address is automatically derived from pool config's migrationFeeOption
+ * - If token has locked vesting parameters, may need to call createLocker() first
+ * - Requires signatures from three keypairs: payer, firstPositionNftKeypair, secondPositionNftKeypair
+ *
+ * @param sdk NaraSDK SDK instance
+ * @param params Migration parameters
+ * @returns Migration transaction, Position NFT keypairs, and pool address
+ */
+export async function migrateToDAMMV2(
+  sdk: NaraSDK,
+  params: MigrateToDAMMV2Params
+): Promise<MigrateToDAMMV2Result> {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey(params.tokenAddress);
+
+  // Get pool account
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${params.tokenAddress}`);
+  }
+
+  // Check if pool has already been migrated
+  if (poolAccount.account.isMigrated) {
+    throw new Error("Pool has already been migrated");
+  }
+
+  // Get pool config and read migrationFeeOption
+  const virtualPool = poolAccount.account;
+  const poolConfig = await client.state.getPoolConfig(virtualPool.config);
+
+  // Get corresponding config address from DAMM_V2_MIGRATION_FEE_ADDRESS array
+  // Using 'any' type since poolConfig's migrationFeeOption is IDL-derived
+  const migrationFeeOption = (poolConfig as any).migrationFeeOption || 0;
+  const dammConfig = DAMM_V2_MIGRATION_FEE_ADDRESS[migrationFeeOption];
+
+  if (!dammConfig) {
+    throw new Error(
+      `Invalid migration fee option: ${migrationFeeOption}. Cannot determine DAMM config address.`
+    );
+  }
+
+  // Note: If the pool has locked vesting parameters, a locker might need to be created first
+  // Use createLocker() if the migration fails due to missing locker
+
+  // Call SDK's migrateToDammV2 method
+  const result = await client.migration.migrateToDammV2({
+    payer: params.payer,
+    virtualPool: poolAccount.publicKey,
+    dammConfig,
+  });
+
+  // Get latest blockhash
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  result.transaction.recentBlockhash = blockhash;
+  result.transaction.feePayer = params.payer;
+
+  // Compile transaction with ALT if configured
+  const compiledTx = await sdk.compileTransactionWithALT(
+    result.transaction,
+    params.payer
+  );
+
+  return {
+    transaction: compiledTx,
+    firstPositionNftKeypair: result.firstPositionNftKeypair,
+    secondPositionNftKeypair: result.secondPositionNftKeypair,
+    poolAddress: poolAccount.publicKey.toBase58(),
+  };
+}
+
+/**
+ * Create Locker (for token pools with locked vesting parameters)
+ *
+ * If the token pool has locked vesting parameters (amountPerPeriod > 0 or cliffUnlockAmount > 0),
+ * a locker must be created before migrating to DAMM V2
+ *
+ * @param sdk NaraSDK SDK instance
+ * @param params Locker parameters
+ * @returns Locker creation transaction and pool address
+ */
+export async function createLocker(
+  sdk: NaraSDK,
+  params: CreateLockerParams
+): Promise<CreateLockerResult> {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey(params.tokenAddress);
+
+  // Get pool account
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${params.tokenAddress}`);
+  }
+
+  // Create locker
+  const transaction = await client.migration.createLocker({
+    payer: params.payer,
+    virtualPool: poolAccount.publicKey,
+  });
+
+  // Get latest blockhash
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  transaction.recentBlockhash = blockhash;
+  transaction.feePayer = params.payer;
+
+  // Compile transaction with ALT if configured
+  const compiledTx = await sdk.compileTransactionWithALT(
+    transaction,
+    params.payer
+  );
+
+  return {
+    transaction: compiledTx,
+    poolAddress: poolAccount.publicKey.toBase58(),
+  };
+}
+
+/**
+ * Check if pool can be launched to DAMM V2
+ *
+ * @param sdk NaraSDK SDK instance
+ * @param tokenAddress Token address (baseMint)
+ * @returns Whether pool can be launched
+ */
+export async function canMigrate(
+  sdk: NaraSDK,
+  tokenAddress: string
+): Promise<{
+  canMigrate: boolean;
+  reason?: string;
+  progress: number;
+}> {
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey(tokenAddress);
+
+  // Get pool account
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    return {
+      canMigrate: false,
+      reason: "Pool not found",
+      progress: 0,
+    };
+  }
+
+  // Check if already migrated
+  if (poolAccount.account.isMigrated) {
+    return {
+      canMigrate: false,
+      reason: "Pool has already been migrated",
+      progress: 1,
+    };
+  }
+
+  // Get curve progress
+  const progress = await client.state.getPoolCurveProgress(
+    poolAccount.publicKey
+  );
+
+  // Check if 100% complete
+  if (progress >= 1.0) {
+    return {
+      canMigrate: true,
+      progress,
+    };
+  }
+
+  return {
+    canMigrate: false,
+    reason: `Curve not complete. Current progress: ${(progress * 100).toFixed(2)}%`,
+    progress,
+  };
+}