Repository files navigation

Kite leverages the speed and elegance of@solana/kit (previously known as@solana/web3.js version 2) but allows you tocomplete most Solana tasks in a single step. Since Kite uses@solana/kit for the heavy lifting, Kite is fully compatible with@solana/kit. If you decide you no longer need Kite, you can easily remove it and use plain@solana/kit.

Users of VSCode and other popular editors will see TSDoc comments with parameters, return types, and usage examples right in their editor.

Kite is for everyone! You don't need to use Helius RPCs to use Kite. However if you do use Helius RPCs, Kite will take advantage of Helius features like priority fee estimates and low-latency transaction confirmation.

Kite works both in the browser and node.js, is small, and hasminimal dependencies. It also works withAnchor.

Kite includes functions for:

• Connect to a Solana cluster

• Create a new wallet
• Create multiple wallets
• Load a wallet from a file
• Load a wallet from an environment variable

• Airdrop SOL if balance is low
• Get a SOL balance
• Transfer SOL between wallets

• Create a new token
• Get token account address
• Get token mint information
• Get token account balance
• 🆕Check if token account is closed
• Mint tokens to a wallet
• Transfer tokens between wallets

• Send a transaction from multiple instructions
• Send and confirm a transaction you're already created
• Check if a transaction is confirmed
• Get transaction logs
• 🆕Get a PDA from seeds

• Get a Solana Explorer link

We'll be adding more functions over time. You're welcome tosuggest a new function or read theCONTRIBUTING guidelines andsend a PR.

Solana itself is named aftera beach. Kite is a high-level framework, so what is high above a beach? Kites! 🪁😃

Coincidentally, a couple of weeks after Kite's release, Solana web3.js version 2 was renamedkit. SoKite now flies on top of Kit.

Yes. Here's afull Anchor demo token Swap app using Kite, Kit and Codama.

npm i @helius-dev/kite

To start Kite, you need to connect to an RPC.

To use the local cluster (ie,solana-test-validator running on your machine):

import{connect}from"@helius-dev/kite";constconnection=connect();

You can also specify a cluster name. The connection object defaults tolocalnet but any of the following cluster names are supported:mainnet-beta (ormainnet),testnet,devnet,helius-mainnet,helius-testnet, orhelius-devnet.

constconnection=connect("helius-devnet");

The Helius names require the environment variableHELIUS_API_KEY to be set in your environment.

You can also specify an arbitrary RPC URL and RPC subscription URL:

constconnection=connect("https://mainnet.example.com/","wss://mainnet.example.com/");

After you've made a connection Kite is ready to use.You don't need to set up any factories, they're already configured. Aconnection has the following functions ready out of the box:

LikeinitializeKeypair from@solana/helpers

Creates a new Solana wallet (more specifically aKeyPairSigner).

If you like, the wallet will have a prefix/suffix of your choice, the wallet will have a SOL balance ready to spend, and the keypair will be saved to a file for you to use later.

Returns:Promise<KeyPairSigner>

constwallet=awaitconnection.createWallet({  prefix,// optional: prefix for wallet address  suffix,// optional: suffix for wallet address  envFileName,// optional: path to .env file to save keypair  envVariableName,// optional: name of environment variable to store keypair  airdropAmount,// optional: amount of SOL to airdrop});

All options are optional:

• prefix:string | null - Prefix for wallet address
• suffix:string | null - Suffix for wallet address
• envFileName:string | null - Path to .env file to save keypair
• envVariableName:string - Name of environment variable to store keypair (default: "PRIVATE_KEY")
• airdropAmount:Lamports | null - Amount of SOL to airdrop (default: 1 SOL)

Create a basic wallet:

constwallet=awaitconnection.createWallet();

Create a wallet with a specific prefix and suffix:

constwallet=awaitconnection.createWallet({prefix:"COOL",suffix:"WALLET",});

Create a wallet and save it to an environment file:

constwallet=awaitconnection.createWallet({envFileName:".env",envVariableName:"MY_WALLET_KEY",});

Create a wallet with a custom airdrop amount:

constwallet=awaitconnection.createWallet({airdropAmount:lamports(2n*SOL),});

LikegetKeypairFromFile from@solana/helpers

Loads a wallet (more specifically aKeyPairSigner) from a file. The file should be in the same format as files created by thesolana-keygen command.

Returns:Promise<KeyPairSigner>

constwallet=awaitconnection.loadWalletFromFile(keyPairPath);

• keyPairPath:string - Path to load keypair from file

LikegetKeypairFromEnvironment from@solana/helpers

Loads a wallet (more specifically aKeyPairSigner) from an environment variable. The keypair should be in the same 'array of numbers' format as used bysolana-keygen.

Returns:Promise<KeyPairSigner>

constwallet=awaitconnection.loadWalletFromEnvironment(envVariableName);

• envVariableName:string - Name of environment variable containing the keypair (default: "PRIVATE_KEY")

LikesendTransaction from@solana/helpers

Sends a transaction and waits for confirmation.

Returns:Promise<void>

awaitconnection.sendAndConfirmTransaction(transaction,options);

• transaction:VersionedTransaction - Transaction to send
• options:Object (optional)
  • commitment:Commitment - Desired confirmation level
  • skipPreflight:boolean - Whether to skip preflight transaction checks

Gets the SOL balance of an account, in lamports.

Returns:Promise<Lamports>

constbalance=awaitconnection.getLamportBalance(address,commitment);

• address:string - Address to check balance for
• commitment:Commitment (optional) - Desired confirmation level (default: "finalized")

Get a link to view an address, transaction, or token on Solana Explorer. The link will automatically use your RPC.

Returns:string - Explorer URL

Get a link to view an address:

constaddressLink=connection.getExplorerLink("address","GkFTrgp8FcCgkCZeKreKKVHLyzGV6eqBpDHxRzg1brRn");

Get a link to view a transaction:

consttransactionLink=connection.getExplorerLink("transaction","5rUQ2tX8bRzB2qJWnrBhHYgHsafpqVZwGwxVrtyYFZXJZs6yBVwerZHGbwsrDHKbRtKpxnWoHKmBgqYXVbU5TrHe",);

Or if you like abbrieviations:

consttransactionLink=connection.getExplorerLink("tx","5rUQ2tX8bRzB2qJWnrBhHYgHsafpqVZwGwxVrtyYFZXJZs6yBVwerZHGbwsrDHKbRtKpxnWoHKmBgqYXVbU5TrHe",);

Get a link to view a block:

constblockLink=connection.getExplorerLink("block","180392470");

• linkType:"transaction" | "tx" | "address" | "block" - Type of entity to link to
• id:string - The address, signature, or block to link to

Checks the confirmation status of a recent transaction.

Returns:Promise<boolean>

constconfirmed=awaitconnection.getRecentSignatureConfirmation(signature);

• signature:string - The signature of the transaction to check

LikeairdropIfRequired from@solana/helpers

Airdrops SOL to an address if its balance is below the specified threshold.

Returns:Promise<string | null> - Transaction signature if airdrop occurred, null if no airdrop was needed

constsignature=awaitconnection.airdropIfRequired(address,airdropAmount,minimumBalance);

• address:Address - Address to check balance and potentially airdrop to
• airdropAmount:Lamports - Amount of lamports to airdrop if needed
• minimumBalance:Lamports - Minimum balance threshold that triggers airdrop

Retrieves logs for a transaction.

Returns:Promise<Array<string>>

constlogs=awaitconnection.getLogs(signature);

• signature:string - Transaction signature to get logs for

Transfers SOL from one wallet to another.

Returns:Promise<Signature>

constsignature=awaitconnection.transferLamports({  source,  destination,  amount,  skipPreflight,  maximumClientSideRetries,  abortSignal,});

• source:KeyPairSigner - The wallet to send SOL from
• destination:Address - The wallet to send SOL to
• amount:Lamports - Amount of lamports to send
• skipPreflight:boolean (optional) - Whether to skip preflight checks (default: true)
• maximumClientSideRetries:number (optional) - Maximum number of times to retry sending the transaction (default: 0)
• abortSignal:AbortSignal | null (optional) - Signal to abort the transaction (default: null)

Creates a new SPL token mint with specified parameters.

Returns:Promise<Address>

• mintAuthority:KeyPairSigner - Authority that can mint new tokens
• decimals:number - Number of decimal places for the token
• name:string - Name of the token
• symbol:string - Symbol of the token
• uri:string - URI pointing to the token's metadata (eg: "https://arweave.net/abc123")
• additionalMetadata:Record<string, string> | Map<string, string> (optional) - Additional metadata fields

Create a token with additional metadata:

constmintAddress=awaitconnection.createTokenMint({mintAuthority:wallet,decimals:9,name:"My Token",symbol:"MYTKN",uri:"https://example.com/token-metadata.json",additionalMetadata:{description:"My custom token",},});

Ametadata.json file, and any images inside, should be hosted at andecentralized storage service. The file itself is at minimum:

{"image":"https://raw.githubusercontent.com/solana-developers/opos-asset/main/assets/CompressedCoil/image.png"}

Images should be square, and either 512x512 or 1024x1024 pixels, and less than 100kb if possible.

Gets the associated token account address for a given wallet and token mint.

Returns:Promise<Address>

consttokenAccountAddress=awaitconnection.getTokenAccountAddress(wallet,mint,useTokenExtensions);

• wallet:Address - The wallet address to get the token account for
• mint:Address - The token mint address
• useTokenExtensions:boolean (optional) - Whether to use Token Extensions program (default: false)

Get a token account address for a token made with the classic token program:

consttokenAccountAddress=awaitconnection.getTokenAccountAddress("GkFTrgp8FcCgkCZeKreKKVHLyzGV6eqBpDHxRzg1brRn","EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",);

Get a token account address for a Token Extensions token:

consttokenAccountAddress=awaitconnection.getTokenAccountAddress("GkFTrgp8FcCgkCZeKreKKVHLyzGV6eqBpDHxRzg1brRn","EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",true,);

Mints tokens from a token mint to a destination account. The mint authority must sign the transaction.

Returns:Promise<Signature>

constsignature=awaitconnection.mintTokens(mintAddress,// address of the token mintmintAuthority,// signer with authority to mint tokensamount,// amount of tokens to mintdestination,// address to receive the tokens);

• mintAddress:Address - Address of the token mint
• mintAuthority:KeyPairSigner - Signer with authority to mint tokens
• amount:bigint - Amount of tokens to mint (in base units)
• destination:Address - Address to receive the minted tokens

// Create a new token mintconstmintAuthority=awaitconnection.createWallet({airdropAmount:lamports(1n*SOL),});constmintAddress=awaitconnection.createTokenMint(mintAuthority,9,// decimals"My Token","TKN","https://example.com/token.json",);// Mint 100 tokens to the mint authority's accountconstsignature=awaitconnection.mintTokens(mintAddress,mintAuthority,100n,mintAuthority.address);

Transfers tokens from one account to another. The sender must sign the transaction.

Returns:Promise<Signature>

constsignature=awaitconnection.transferTokens({  sender,  destination,  mintAddress,  amount,  maximumClientSideRetries,  abortSignal,});

• sender:KeyPairSigner - Signer that owns the tokens and will sign the transaction
• destination:Address - Address to receive the tokens
• mintAddress:Address - Address of the token mint
• amount:bigint - Amount of tokens to transfer (in base units)
• maximumClientSideRetries:number (optional) - Maximum number of times to retry sending the transaction (default: 0)
• abortSignal:AbortSignal | null (optional) - Signal to abort the transaction (default: null)

// Create wallets for sender and recipientconst[sender,recipient]=awaitPromise.all([connection.createWallet({airdropAmount:lamports(1n*SOL),}),connection.createWallet({airdropAmount:lamports(1n*SOL),}),]);// Create a new token mintconstmintAddress=awaitconnection.createTokenMint(sender,// sender will be the mint authority9,// decimals"My Token","TKN","https://example.com/token.json",);// Mint some tokens to the sender's accountawaitconnection.mintTokens(mintAddress,sender,100n,sender.address);// Transfer 50 tokens from sender to recipient with retriesconstsignature=awaitconnection.transferTokens({  sender,destination:recipient.address,  mintAddress,amount:50n,maximumClientSideRetries:3,});

LikesendTransactionWithSigners from@solana/helpers

Sends a transaction containing one or more instructions. The transaction will be signed by the fee payer.

Returns:Promise<Signature>

constsignature=awaitconnection.sendTransactionFromInstructions({  feePayer,  instructions,  commitment,  skipPreflight,  maximumClientSideRetries,  abortSignal,});

• feePayer:KeyPairSigner - The account that will pay for the transaction
• instructions:Array<IInstruction> - Array of instructions to include in the transaction
• commitment:"confirmed" | "finalized" (optional) - Desired confirmation level (default: "confirmed")
• skipPreflight:boolean (optional) - Whether to skip preflight transaction checks (default: true)
• maximumClientSideRetries:number (optional) - Maximum number of times to retry sending the transaction (default: 0)
• abortSignal:AbortSignal | null (optional) - Signal to abort the transaction (default: null)

Here's an example of sending a transaction with a SOL transfer instruction:

constfeePayer=awaitconnection.createWallet({airdropAmount:lamports(1n*SOL)});constrecipient=awaitgenerateKeyPairSigner();// Create an instruction to transfer SOLconsttransferInstruction=getTransferSolInstruction({amount:lamports(0.1n*SOL),destination:recipient.address,source:feePayer});// Send the transaction with the transfer instructionconstsignature=awaitconnection.sendTransactionFromInstructions({  feePayer,instructions:[transferInstruction],maximumClientSideRetries:3// retry up to 3 times if the transaction fails});

You can also send multiple instructions in a single transaction:

// Create instructions to transfer SOL to multiple recipientsconsttransferInstructions=recipients.map(recipient=>getTransferSolInstruction({amount:lamports(0.1n*SOL),destination:recipient.address,source:feePayer}));// Send all transfers in one transactionconstsignature=awaitconnection.sendTransactionFromInstructions({  feePayer,instructions:transferInstructions,commitment:"confirmed",skipPreflight:true});

The function will automatically:

• Get a recent blockhash
• Set the fee payer
• Add compute budget instructions if needed
• Sign the transaction with the fee payer
• Send and confirm the transaction
• Retry the transaction if requested and needed

Gets information about a token mint, including its decimals, authority, and supply.

Returns:Promise<Mint | null>

constmint=awaitconnection.getMint(mintAddress,commitment);

• mintAddress:Address - Address of the token mint to get information for
• commitment:Commitment (optional) - Desired confirmation level (default: "confirmed")

// Get information about the USDC mintconstusdcMint=awaitconnection.getMint("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");if(usdcMint){console.log(`Decimals:${usdcMint.data.decimals}`);console.log(`Mint authority:${usdcMint.data.mintAuthority}`);console.log(`Supply:${usdcMint.data.supply}`);}

The mint information includes:

• decimals: Number of decimal places for the token
• mintAuthority: Public key of the account allowed to mint new tokens
• supply: Current total supply of the token
• Other metadata if the token uses Token Extensions

LikemakeWallets from@solana/helpers

Creates multiple Solana wallets with the same options. Returns an array of wallet promises that can be awaited in parallel.

Returns:Array<Promise<KeyPairSigner>>

constwallets=awaitconnection.createWallets(amount,options);

• amount:number - Number of wallets to create
• options: Same options ascreateWallet:
  • prefix:string | null - Prefix for wallet addresses
  • suffix:string | null - Suffix for wallet addresses
  • envFileName:string | null - Path to .env file to save keypairs
  • envVariableName:string - Name of environment variable to store keypairs
  • airdropAmount:Lamports | null - Amount of SOL to airdrop to each wallet

Create 3 wallets with airdrops:

const[wallet1,wallet2,wallet3]=awaitconnection.createWallets(3,{airdropAmount:lamports(1n*SOL),});

If you need to create multiple wallets with different options, you can do this with:

const[sender,recipient]=awaitPromise.all([connection.createWallet({airdropAmount:lamports(1n*SOL),}),connection.createWallet({airdropAmount:lamports(1n*SOL),}),]);

Gets the balance of tokens in a token account for a given wallet and mint.

Returns:Promise<TokenAmount>

constbalance=awaitconnection.getTokenAccountBalance(wallet,mint,useTokenExtensions);

• wallet:Address - The wallet address to check the token balance for
• mint:Address - The token mint address
• useTokenExtensions:boolean (optional) - Whether to use Token Extensions program (default: false)

Get a token balance for a classic SPL token:

// Get USDC balanceconstbalance=awaitconnection.getTokenAccountBalance("GkFTrgp8FcCgkCZeKreKKVHLyzGV6eqBpDHxRzg1brRn",// wallet"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",// USDC mint);console.log(`Balance:${balance.uiAmount}${balance.symbol}`);

Get a token balance for a Token Extensions token:

constbalance=awaitconnection.getTokenAccountBalance("GkFTrgp8FcCgkCZeKreKKVHLyzGV6eqBpDHxRzg1brRn","EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",true,// use Token Extensions program);

The balance includes:

• amount: Raw token amount (in base units)
• decimals: Number of decimal places for the token
• uiAmount: Formatted amount with decimals
• uiAmountString: String representation of the UI amount

Checks if a token account is closed or doesn't exist. A token account can be specified directly or derived from a wallet and mint address.

Returns:Promise<boolean>

constisClosed=awaitconnection.checkTokenAccountIsClosed(params);

• params:Object - Parameters for checking token account
  • tokenAccount:Address (optional) - Direct token account address to check
  • wallet:Address (optional) - Wallet address (required if tokenAccount not provided)
  • mint:Address (optional) - Token mint address (required if tokenAccount not provided)
  • useTokenExtensions:boolean (optional) - Use Token-2022 program instead of Token program (default: false)

Check if a token account is closed using direct token account address:

consttokenAccount="4MD31b2GFAWVDYQT8KG7E5GcZiFyy4MpDUt4BcyEdJRP";constisClosed=awaitconnection.checkTokenAccountIsClosed({  tokenAccount,});console.log(`Token account is${isClosed ?"closed" :"open"}`);

Check if a token account is closed using wallet and mint:

constisClosed=awaitconnection.checkTokenAccountIsClosed({wallet:"GkFTrgp8FcCgkCZeKreKKVHLyzGV6eqBpDHxRzg1brRn",mint:"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",useTokenExtensions:true,});console.log(`Token account is${isClosed ?"closed" :"open"}`);

Gets a Program Derived Address (PDA) and its bump seed from a program address and seeds. Automatically handles encoding of different seed types.

Returns:Promise<{pda: Address, bump: number}>

const{ pda, bump}=awaitconnection.getPDAAndBump(programAddress,seeds);

• programAddress:Address - The program address to derive the PDA from
• seeds:Array<String | Address | BigInt> - Array of seeds to derive the PDA. Can include:
  • Strings (encoded as UTF-8)
  • Addresses (encoded as base58)
  • BigInts (encoded as 8-byte little-endian)

constprogramAddress="TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"asAddress;constseeds=["offer",// string seedaliceAddress,// address seed420n,// bigint seed];const{ pda, bump}=awaitconnection.getPDAAndBump(programAddress,seeds);console.log("PDA:",pda.toString());console.log("Bump seed:",bump);

Since this is a library, all functions in the codebase must include TSDoc comments that describe their purpose, parameters, and return types. I appreciate TSDoc can be annoying and reptitive, but we use TSdoc because VSCode and other IDEs show these comments when the function is hovered. See existing functions for examples of the required documentation format.

Make the TSDoc comments actually useful. Eg, don't tell people thatmintAuthority is 'the mint authority'. Tell them thatmintAuthority is 'the account that is allowed to use the token mint'.

To run tests, open a terminal tab, and run:

solana-test-validator

Then in a different tab, run:

npm runtest

The tests use thenode native test runner.

If you'd like to run a single test, use:

npx tsx --test --no-warnings src/tests/keypair.test.ts

We use--no-warnings to avoidExperimentalWarning: The Ed25519 Web Crypto API algorithm is an experimental feature which is pretty boring once you've read it for the 50th time.

To just run tests matching the nameconnect:

npx tsx --test --no-warnings --test-name-pattern="connect"