🤖Bot SDK - Solana

Calculate prices and prepare buy/sell transactions via the Moonshot SDK

Join our developer TG channel for important updates.

The trading instructions for buy and sell (but not mint) are directly available on-chain via the Moonshot Smart Contract, also accessible via CPI.

Overview

The Moonshot SDK provides the following functions:

• Minting of a token

  • Prepare and submit transactions

  • Upload all assets

  • Buy an initial amount of the tokens you minted

• Get price of the token / position on bonding curve

• Calculate collateral/token in and out

• Buy and sell transactions (both exact in and out)

Installation

npm: @wen-moon-ser/moonshot-sdknpm

Example code

Generate a keypair and send funds for the right environment (devnet or mainnet).

https://github.com/wen-moon-ser/moonshot-bot-examplesgithub.com

Example in Wen moon repo

Initializing Moonshot

To initialize the Moonshot SDK, you need to create an instance of the Moonshot class.

Parameters:

• environment : You can initialize the environment for either mainnet or devnet

  • For Mainnet, use Environment.MAINNET

  • For Devnet, use Environemnt.DEVNET

• rpcUrl : Your RPC URL based on the Environment

  • Public endpoint for Mainnet : 'https://api.mainnet-beta.solana.com'

  • Public endpoint for Devnet : ‘https://api.devnet.solana.com’

• authToken : “YOUR_AUTH_TOKEN”. This can be an empty string for now

• chainOptions : chain specific options for confirmed commitments

Mint Example

• Image size restrictions - 2 MB for the icon and 5 MB for the banner

• Recommended aspect ratio - 1 : 1 for the icon and 3:1 for the banner

• tokenAmount - Lets you buy an initial amount of tokens that you just minted

import {
  CurveType,
  Environment,
  MigrationDex,
  Moonshot,
  SolanaSerializationService,
  imagePathToBase64,
} from '@wen-moon-ser/moonshot-sdk';
import { Keypair } from '@solana/web3.js';
import testWallet from '../../test-wallet.json';

export const createMint = async (): Promise<void> => {
  console.log('--- Create mint example ---');

  const creator = Keypair.fromSecretKey(Uint8Array.from(testWallet));
  console.log('Creator: ', creator.publicKey.toBase58());

  const moonshot = new Moonshot({
    rpcUrl: 'https://api.devnet.solana.com',
    environment: Environment.DEVNET,
    chainOptions: {
      solana: { confirmOptions: { commitment: 'confirmed' } },
    },
  });

  const icon = imagePathToBase64('src/assets/icon.png'); // see above for recommended size and aspect ratio

  const prepMint = await moonshot.prepareMintTx({
    creator: creator.publicKey.toBase58(),
    name: 'SDK_MINT',
    symbol: 'SDK_MINT',
    curveType: CurveType.CONSTANT_PRODUCT_V1,
    migrationDex: MigrationDex.RAYDIUM,
    icon,
    description: 'Token minted using the @wen-moon-ser/moonshot-sdk',
    links: [{ url: 'https://x.com', label: 'x handle' }],
    banner: icon,
    tokenAmount: '42000000000', // Lets you buy an initial amount of tokens that you just minted
  });

  const deserializedTransaction =
    SolanaSerializationService.deserializeVersionedTransaction(
      prepMint.transaction,
    );
  if (deserializedTransaction == null) {
    throw new Error('Failed to deserialize transaction');
  }

  deserializedTransaction.sign([creator]);

  const signedTransaction =
    SolanaSerializationService.serializeVersionedTransaction(
      deserializedTransaction,
    );

  const res = await moonshot.submitMintTx({
    tokenId: prepMint.tokenId,
    token: prepMint.token,
    signedTransaction,
  });

  console.log(res);
};

Buy Example

import { Environment, FixedSide, Moonshot } from '@wen-moon-ser/moonshot-sdk';
import {
  ComputeBudgetProgram,
  Connection,
  Keypair,
  TransactionMessage,
  VersionedTransaction,
} from '@solana/web3.js';
import testWallet from '../test-wallet.json';

export const buyIx = async (): Promise<void> => {
  console.log('--- Buying token example ---');

  const rpcUrl = 'https://api.devnet.solana.com';

  const connection = new Connection(rpcUrl);

  const moonshot = new Moonshot({
    rpcUrl,
    environment: Environment.DEVNET,
    chainOptions: {
      solana: { confirmOptions: { commitment: 'confirmed' } },
    },
  });

  const token = moonshot.Token({
    mintAddress: '3Rai792zaN5adyc2oEFGg1JLV4S9SYi51HrtMw7qRz8o',
  });

  const curvePos = await token.getCurvePosition();
  console.log('Current position of the curve: ', curvePos); // Prints the current curve position

  // make sure creator has funds
  const creator = Keypair.fromSecretKey(Uint8Array.from(testWallet));
  console.log('Creator: ', creator.publicKey.toBase58());

  const tokenAmount = 10000n * 1000000000n; // Buy 10k tokens

  // Buy example
  const collateralAmount = await token.getCollateralAmountByTokens({
    tokenAmount,
    tradeDirection: 'BUY',
  });

  const { ixs } = await token.prepareIxs({
    slippageBps: 500,
    creatorPK: creator.publicKey.toBase58(),
    tokenAmount,
    collateralAmount,
    tradeDirection: 'BUY',
    fixedSide: FixedSide.OUT, // This means you will get exactly the token amount and slippage is applied to collateral amount
  });

  const priorityIx = ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: 200_000,
  });

  const blockhash = await connection.getLatestBlockhash('confirmed');
  const messageV0 = new TransactionMessage({
    payerKey: creator.publicKey,
    recentBlockhash: blockhash.blockhash,
    instructions: [priorityIx, ...ixs],
  }).compileToV0Message();

  const transaction = new VersionedTransaction(messageV0);

  transaction.sign([creator]);
  const txHash = await connection.sendTransaction(transaction, {
    skipPreflight: false,
    maxRetries: 0,
    preflightCommitment: 'confirmed',
  });

  console.log('Buy Transaction Hash:', txHash);
};

Sell Example

import { Environment, FixedSide, Moonshot } from '@wen-moon-ser/moonshot-sdk';
import {
  ComputeBudgetProgram,
  Connection,
  Keypair,
  TransactionMessage,
  VersionedTransaction,
} from '@solana/web3.js';
import testWallet from '../test-wallet.json';

export const sellIx = async (): Promise<void> => {
  console.log('--- Selling token example ---');
  const rpcUrl = 'https://api.devnet.solana.com';

  const connection = new Connection(rpcUrl);

  const moonshot = new Moonshot({
    rpcUrl,
    environment: Environment.DEVNET,
    chainOptions: {
      solana: { confirmOptions: { commitment: 'confirmed' } },
    },
  });

  const token = moonshot.Token({
    mintAddress: '3Rai792zaN5adyc2oEFGg1JLV4S9SYi51HrtMw7qRz8o',
  });

  const curvePos = await token.getCurvePosition();
  console.log('Current position of the curve: ', curvePos); // Prints the current curve position

  // make sure creator has funds
  const creator = Keypair.fromSecretKey(Uint8Array.from(testWallet));
  console.log('Creator: ', creator.publicKey.toBase58());

  const tokenAmount = 10000n * 1000000000n; // Buy 10k tokens

  // Buy example
  const collateralAmount = await token.getCollateralAmountByTokens({
    tokenAmount,
    tradeDirection: 'SELL',
  });

  const { ixs } = await token.prepareIxs({
    slippageBps: 500,
    creatorPK: creator.publicKey.toBase58(),
    tokenAmount,
    collateralAmount,
    tradeDirection: 'SELL',
    fixedSide: FixedSide.IN, // This means you will pay exactly the token amount slippage is applied to collateral amount
  });

  const priorityIx = ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: 200_000,
  });

  const blockhash = await connection.getLatestBlockhash('confirmed');
  const messageV0 = new TransactionMessage({
    payerKey: creator.publicKey,
    recentBlockhash: blockhash.blockhash,
    instructions: [priorityIx, ...ixs],
  }).compileToV0Message();

  const transaction = new VersionedTransaction(messageV0);

  transaction.sign([creator]);
  const txHash = await connection.sendTransaction(transaction, {
    skipPreflight: false,
    maxRetries: 0,
    preflightCommitment: 'confirmed',
  });

  console.log('Sell Transaction Hash:', txHash);
};
Readme