Launch a Token with a Non-SOL Quote Token

# .env
BAGS_API_KEY=your_api_key_here
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
PRIVATE_KEY=your_base58_encoded_private_key_here  # Required for this guide

const quoteTokens = await sdk.tokenLaunch.getDammV2SupportedQuoteTokens();

for (const token of quoteTokens) {
    console.log(`${token.symbol ?? "(no symbol)"} — ${token.mint} (${token.decimals} decimals)`);
}

// launch-token-non-sol-quote.ts
import dotenv from "dotenv";
dotenv.config({ quiet: true });

import { BagsSDK, signAndSendTransaction } from "@bagsfm/bags-sdk";
import { Keypair, Connection, PublicKey, VersionedTransaction } from "@solana/web3.js";
import bs58 from "bs58";

// Initialize SDK
const BAGS_API_KEY = process.env.BAGS_API_KEY;
const SOLANA_RPC_URL = process.env.SOLANA_RPC_URL;
const PRIVATE_KEY = process.env.PRIVATE_KEY;

if (!BAGS_API_KEY || !SOLANA_RPC_URL || !PRIVATE_KEY) {
    throw new Error("BAGS_API_KEY, SOLANA_RPC_URL, and PRIVATE_KEY are required");
}

const connection = new Connection(SOLANA_RPC_URL);
const sdk = new BagsSDK(BAGS_API_KEY, connection, "processed");

// The launch bundle is returned as ordered, base58-encoded transactions with a `type`
// label. LUT_SETUP, CREATE_TOKEN, and LAUNCH complete the launch; LUT_DEACTIVATE and
// LUT_CLOSE are optional cleanup that reclaim the lookup-table rent afterwards.
const CORE_LAUNCH_STEPS = ["LUT_SETUP", "CREATE_TOKEN", "LAUNCH"] as const;

async function launchToken(launchParams: {
    imageUrl: string;
    name: string;
    symbol: string;
    description: string;
    quoteMint: string;          // From getDammV2SupportedQuoteTokens()
    twitterUrl?: string;
    websiteUrl?: string;
    telegramUrl?: string;
    // Optional: initial buy amount, in the quote mint's BASE UNITS (not SOL, not whole tokens)
    initialBuyQuoteAmount?: number;
    // Optional: wallet that receives the creator fee position (defaults to the launch wallet)
    feeClaimerWallet?: PublicKey;
    // Optional: an existing partner config wallet to attach to the custody
    partner?: PublicKey;
}) {
    if (!PRIVATE_KEY) {
        throw new Error("PRIVATE_KEY is not set");
    }

    const keypair = Keypair.fromSecretKey(bs58.decode(PRIVATE_KEY));
    const commitment = sdk.state.getCommitment();

    console.log(`🚀 Launching $${launchParams.symbol} with wallet ${keypair.publicKey.toBase58()}`);

    // Step 1: Create metadata
    console.log("📝 Step 1: Creating token info and metadata...");
    const tokenInfo = await sdk.tokenLaunch.createTokenInfoAndMetadata({
        imageUrl: launchParams.imageUrl,
        name: launchParams.name,
        description: launchParams.description,
        symbol: launchParams.symbol?.toUpperCase()?.replace("$", ""),
        twitter: launchParams.twitterUrl,
        website: launchParams.websiteUrl,
        telegram: launchParams.telegramUrl,
    });

    console.log("🪙 Token mint:", tokenInfo.tokenMint);

    // Step 2: Build the DAMM v2 direct launch bundle
    console.log("🎯 Step 2: Building the launch transaction bundle...");
    const { transactions, launch } = await sdk.tokenLaunch.createDammV2LaunchTransaction({
        metadataUrl: tokenInfo.tokenMetadata,
        tokenMint: new PublicKey(tokenInfo.tokenMint),
        wallet: keypair.publicKey,
        quoteMint: new PublicKey(launchParams.quoteMint),
        feeClaimerWallet: launchParams.feeClaimerWallet,
        initialBuyQuoteAmount: launchParams.initialBuyQuoteAmount,
        partner: launchParams.partner,
    });

    console.log("🏊 Pool:", launch.pool);
    console.log("💵 Launch price (quote per token):", launch.launchPriceQuotePerToken);
    console.log("📊 Implied launch FDV (USD):", launch.impliedLaunchFdvUsd);

    // Step 3: Sign and submit the bundle IN ORDER.
    // Each item is a base58-encoded transaction already partially signed by the server;
    // your wallet co-signs. Submit LUT_SETUP, then CREATE_TOKEN, then LAUNCH.
    console.log("📡 Step 3: Signing and submitting the launch bundle...");
    for (const step of CORE_LAUNCH_STEPS) {
        const item = transactions.find((tx) => tx.type === step);
        if (!item) continue; // CREATE_TOKEN is skipped on rebuilds where the mint already landed

        const transaction = VersionedTransaction.deserialize(bs58.decode(item.transaction));
        const signature = await signAndSendTransaction(connection, commitment, transaction, keypair);
        console.log(`✅ ${step} confirmed: ${signature}`);
    }

    console.log("🎉 Token launched successfully!");
    console.log(`🌐 View your token at: https://bags.fm/${tokenInfo.tokenMint}`);

    return { tokenMint: tokenInfo.tokenMint, launch };
}

// Example: launch a token quoted in a non-SOL badged mint, with no initial buy.
// Replace quoteMint with a mint returned by getDammV2SupportedQuoteTokens().
launchToken({
    imageUrl: "https://img.freepik.com/premium-vector/white-abstract-vactor-background-design_665257-153.jpg",
    name: "My Equity Token",
    symbol: "MET",
    description: "A token quoted in a non-SOL asset",
    quoteMint: "REPLACE_WITH_SUPPORTED_QUOTE_MINT",
});

const { launches } = await sdk.tokenLaunch.getDammV2Launches({
    quoteMint: new PublicKey("REPLACE_WITH_SUPPORTED_QUOTE_MINT"),
    limit: 20,
});

console.log(`Found ${launches.length} launch(es)`);

const BASE_URL = "https://public-api-v2.bags.fm/api/v1";

async function claimCreatorFees(tokenMint: string, keypair: Keypair) {
    const commitment = sdk.state.getCommitment();

    // 1. Find the claimable DAMM v2 direct position for this wallet + token
    const positionsRes = await fetch(
        `${BASE_URL}/token-launch/claimable-positions?wallet=${keypair.publicKey.toBase58()}`,
        { headers: { "x-api-key": BAGS_API_KEY! } }
    );
    const { response: positions } = await positionsRes.json();

    const position = positions.find(
        (p: any) => p.launchType === "DAMM_V2_DIRECT" && p.baseMint === tokenMint
    );

    if (!position) {
        console.log("No claimable fees for this token.");
        return;
    }

    console.log(`💰 Claimable: ${position.claimableDisplayAmount} (in quote token)`);

    // 2. Build claim transactions. The position's `dammPositionInfo` already contains every
    //    field claim-txs/v2 needs, so post it directly as the request body.
    const claimRes = await fetch(`${BASE_URL}/token-launch/claim-txs/v2`, {
        method: "POST",
        headers: {
            "x-api-key": BAGS_API_KEY!,
            "content-type": "application/json",
        },
        body: JSON.stringify(position.dammPositionInfo),
    });
    const { response: claimTxs } = await claimRes.json();

    // 3. Sign and send each returned transaction
    for (const { tx } of claimTxs) {
        const transaction = VersionedTransaction.deserialize(bs58.decode(tx));
        const signature = await signAndSendTransaction(connection, commitment, transaction, keypair);
        console.log(`✅ Claim confirmed: ${signature}`);
    }
}

async function sweepVaults(keypair: Keypair) {
    const commitment = sdk.state.getCommitment();

    // 1. List every non-empty vault balance for this wallet
    const vaults = await sdk.tokenLaunch.getDammV2VaultClaimables(keypair.publicKey);

    if (vaults.length === 0) {
        console.log("No vault balances to claim.");
        return;
    }

    // 2. Sweep each vault
    for (const vault of vaults) {
        console.log(`💰 ${vault.kind} vault: ${vault.claimableDisplayAmount} (quote mint ${vault.quoteMint})`);

        const { transaction } = await sdk.tokenLaunch.claimDammV2Vault({
            kind: vault.kind,                          // "partner" | "deployer"
            wallet: keypair.publicKey,
            quoteMint: new PublicKey(vault.quoteMint),
        });

        // claimDammV2Vault returns a VersionedTransaction (already decoded)
        const signature = await signAndSendTransaction(connection, commitment, transaction, keypair);
        console.log(`✅ Vault swept: ${signature}`);
    }
}

npx ts-node launch-token-non-sol-quote.ts