@flipflop-sdk/node/dist/launch.js

FlipFlop Node.js SDK for programmatic token operations

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.launchToken = void 0;
const web3_js_1 = require("@solana/web3.js");
const utils_1 = require("./utils");
const constants_1 = require("./constants");
const spl_token_1 = require("@solana/spl-token");
const config_1 = require("./config");
// Launch token function
const launchToken = async (options) => {
    // Validate required parameters
    if (!options.rpc) {
        return {
            success: false,
            message: "Missing rpc parameter",
        };
    }
    if (!options.tokenType) {
        return {
            success: false,
            message: "Missing token-type parameter",
        };
    }
    if (!options.creator) {
        return {
            success: false,
            message: "Missing creator parameter",
        };
    }
    if (!options.name || !options.symbol) {
        return {
            success: false,
            message: "Missing name or symbol parameter",
        };
    }
    const type = options.tokenType;
    const rpc = new web3_js_1.Connection(options.rpc, "confirmed");
    const config = config_1.CONFIGS[(0, config_1.getNetworkType)(options.rpc)];
    try {
        // Load keypair and create wallet (keypair-file takes priority)
        const creator = options.creator;
        const { program, provider, programId } = await (0, utils_1.initProvider)(rpc, creator);
        // Token parameters
        const tokenName = options.name;
        const tokenSymbol = options.symbol;
        const tokenUri = options.uri ||
            `https://example.com/metadata/${tokenSymbol.toLowerCase()}.json`;
        const initConfigData = constants_1.TOKEN_PARAMS[type];
        // Token metadata
        const metadata = {
            name: tokenName,
            symbol: tokenSymbol,
            uri: tokenUri,
            decimals: 9,
        };
        const [launchRuleAccountPda] = web3_js_1.PublicKey.findProgramAddressSync([
            Buffer.from(constants_1.LAUNCH_RULE_SEEDS),
            new web3_js_1.PublicKey(config.systemManagerAccount).toBuffer(),
        ], programId);
        const [systemConfigAccount] = web3_js_1.PublicKey.findProgramAddressSync([
            Buffer.from(constants_1.SYSTEM_CONFIG_SEEDS),
            new web3_js_1.PublicKey(config.systemManagerAccount).toBuffer(),
        ], programId);
        const systemConfigData = await program.account.systemConfigData.fetch(systemConfigAccount);
        const protocolFeeAccount = systemConfigData.protocolFeeAccount;
        const [mintAccount] = web3_js_1.PublicKey.findProgramAddressSync([
            Buffer.from(constants_1.MINT_SEED),
            Buffer.from(metadata.name),
            Buffer.from(metadata.symbol.toLowerCase()),
        ], programId);
        const [configAccount] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(constants_1.CONFIG_DATA_SEED), mintAccount.toBuffer()], programId);
        // Create medatata PDA
        const [metadataAccountPda] = web3_js_1.PublicKey.findProgramAddressSync([
            Buffer.from(constants_1.METADATA_SEED),
            constants_1.TOKEN_METADATA_PROGRAM_ID.toBuffer(),
            mintAccount.toBuffer(),
        ], constants_1.TOKEN_METADATA_PROGRAM_ID);
        const info = await provider.connection.getAccountInfo(mintAccount);
        if (info) {
            return {
                success: false,
                message: `Token already exists: ${mintAccount.toBase58()}`,
            };
        }
        const mintTokenVaultAta = await (0, spl_token_1.getAssociatedTokenAddress)(mintAccount, mintAccount, true, spl_token_1.TOKEN_PROGRAM_ID);
        const tokenVaultAta = await (0, spl_token_1.getAssociatedTokenAddress)(mintAccount, configAccount, true, spl_token_1.TOKEN_PROGRAM_ID);
        const wsolVaultAta = await (0, spl_token_1.getAssociatedTokenAddress)(spl_token_1.NATIVE_MINT, configAccount, true, spl_token_1.TOKEN_PROGRAM_ID);
        const contextInitializeToken = {
            metadata: metadataAccountPda,
            payer: creator.publicKey,
            mint: mintAccount,
            configAccount,
            mintTokenVault: mintTokenVaultAta,
            tokenVault: tokenVaultAta,
            wsolMint: spl_token_1.NATIVE_MINT,
            wsolVault: wsolVaultAta,
            systemConfigAccount: systemConfigAccount,
            protocolFeeAccount: protocolFeeAccount,
            tokenMetadataProgram: constants_1.TOKEN_METADATA_PROGRAM_ID,
            launchRuleAccount: launchRuleAccountPda,
        };
        const ix0 = web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: 500000 });
        const instructionInitializeToken = await program.methods
            .initializeToken(metadata, initConfigData)
            .accounts(contextInitializeToken)
            .instruction();
        const transaction = new web3_js_1.Transaction().add(ix0).add(instructionInitializeToken);
        const tx = await provider.sendAndConfirm(transaction, [creator]);
        const configData = await (0, utils_1.parseConfigData)(program, configAccount);
        // Return structured data instead of console output
        return {
            success: true,
            data: {
                transactionHash: tx,
                mintAddress: mintAccount,
                configAddress: configAccount,
                metadata: metadata,
                configuration: configData,
            },
        };
    }
    catch (error) {
        return {
            success: false,
            message: `Failed to launch token: ${error instanceof Error ? error.message : "Unknown error"}`,
        };
    }
};
exports.launchToken = launchToken;
//# sourceMappingURL=launch.js.map