Home Original page

GitHub - SolWorks-Dev/soltoolkit-sdk: A TypeScript toolkit for developers building on Solana.

SolToolkit

This repository provides open source access to SolToolkit (Typescript) SDK.

Installation

npm i @solworks/soltoolkit-sdk

Modules

ConnectionManager

ConnectionManager is a singleton class that manages web3.js Connection(s). It takes the following parameters on initialization using the async getInstance() method:

{
    network: Cluster;
    endpoint?: string;
    endpoints?: string[];
    config?: ConnectionConfig;
    commitment?: Commitment;
    mode?: Mode;
}

Parameters

  • network is the cluster to connect to, possible values are 'mainnet-beta', 'testnet', 'devnet', 'localnet'. This is required. If you do not pass in any values for endpoint or endpoints, the default endpoints for the network will be used.
  • endpoint is a single endpoint to connect to. This is optional.
  • endpoints is an array of endpoints to connect to. This is optional.
  • config is a web3.js ConnectionConfig object. This is optional.
  • commitment is the commitment level to use for transactions. This is optional, will default to 'max'.
  • mode is the Mode for the ConnectionManager. This is optional, will default to 'single'. Possible values are:
    • 'single' - Uses the endpoint param, that falls back to the first endpoint provided in endpoints, that falls back to the default endpoints for the network.
    • 'first' - Uses the first endpoint provided in endpoints. Throws an error if no endpoints are provided.
    • 'last' - Uses the last endpoint provided in endpoints. Throws an error if no endpoints are provided.
    • 'round-robin' - Uses the endpoints provided in endpoints in a round-robin fashion (cycles through each endpoint in sequence starting from the first). Throws an error if no endpoints are provided.
    • 'random' - Uses a random endpoint provided in endpoints. Throws an error if no endpoints are provided.
    • 'fastest' - Uses the fastest endpoint provided in endpoints. Throws an error if no endpoints are provided.
    • 'highest-slot' - Uses the endpoint with the highest slot provided in endpoints. Throws an error if no endpoints are provided.

Methods

  • getInstance() - Returns the singleton instance of the ConnectionManager. This method is async and must be awaited.
  • getInstanceSync() - Returns the singleton instance of the ConnectionManager. This method is synchronous. This method should only be used after initializing the ConnectionManager with getInstance().
  • conn() - Returns a web3.js connection. This method will update the summary for each RPC to determine the 'fastest' or 'highest slot' endpoint. This method is async and must be awaited.
  • connSync() - Returns a web3.js connection. This method will use fastest' or 'highest slot' endpoint determined during initialization. This method is synchronous.

Examples

Fetching the fastest RPC endpoint

import { ConnectionManager } from "@solworks/soltoolkit-sdk";

(async () => {
  // create connection manager
  const cm = await ConnectionManager.getInstance({
    commitment: "max",
    endpoints: [
      "https://api.devnet.solana.com",
      "https://solana-devnet-rpc.allthatnode.com",
      "https://mango.devnet.rpcpool.com",
      "https://rpc.ankr.com/solana_devnet",
    ],
    mode: "fastest",
    network: "devnet"
  });

  // get fastest endpoint
  const fastestEndpoint = cm._fastestEndpoint;
  console.log(`Fastest endpoint: ${fastestEndpoint}`);
})();

Fetching the highest slot RPC endpoint

import { ConnectionManager, Logger } from "@solworks/soltoolkit-sdk";

(async () => {
  // create connection manager
  const cm = await ConnectionManager.getInstance({
    commitment: "max",
    endpoints: [
      "https://api.devnet.solana.com",
      "https://solana-devnet-rpc.allthatnode.com",
      "https://mango.devnet.rpcpool.com",
      "https://rpc.ankr.com/solana_devnet",
    ],
    mode: "highest-slot",
    network: "devnet"
  });

  // get highest slot endpoint
  const highestSlotEndpoint = cm._highestSlotEndpoint;
  console.log(`Highest slot endpoint: ${_highestSlotEndpoint}`);
})();

Fetching a summary of RPC speeds

import { ConnectionManager, Logger } from "@solworks/soltoolkit-sdk";

(async () => {
  const logger = new Logger("example");

  // create connection manager
  const cm = await ConnectionManager.getInstance({
    commitment: "max",
    endpoints: [
      "https://api.devnet.solana.com",
      "https://solana-devnet-rpc.allthatnode.com",
      "https://mango.devnet.rpcpool.com",
      "https://rpc.ankr.com/solana_devnet",
    ],
    mode: "fastest",
    network: "devnet"
  });

  // get summary of endpoint speeds
  const summary = await cm.getEndpointsSummary();
  logger.debug(JSON.stringify(summary, null, 2));
})();

Transfer SOL to 1 user

import { Keypair, LAMPORTS_PER_SOL, Signer } from "@solana/web3.js";
import {
  ConnectionManager,
  TransactionBuilder,
  TransactionWrapper,
  Logger
} from "@solworks/soltoolkit-sdk";

const logger = new Logger("example");
const sender = Keypair.generate();
const receiver = Keypair.generate();

(async () => {
  // create connection manager
  const cm = await ConnectionManager.getInstance({
    commitment: COMMITMENT,
    endpoints: [
      "https://api.devnet.solana.com",
      "https://solana-devnet-rpc.allthatnode.com",
      "https://mango.devnet.rpcpool.com",
      "https://rpc.ankr.com/solana_devnet",
    ],
    mode: "fastest",
    network: "devnet",
  });

  // airdrop sol to the generated address
  const airdropSig = await cm
    .connSync({ airdrop: true })
    .requestAirdrop(sender.publicKey, LAMPORTS_PER_SOL);

  // confirm airdrop tx
  await TransactionWrapper.confirmTx({
    connectionManager: cm,
    changeConn: false,
    signature: airdropSig,
    commitment: "max",
  });

  // create builder and add token transfer ix
  var builder = TransactionBuilder
    .create()
    .addSolTransferIx({
      from: sender.publicKey,
      to: receiver.publicKey,
      amountLamports: 10_000_000,
    })
    .addMemoIx({
      memo: "gm",
      signer: sender.publicKey,
    });

  // build the transaction
  // returns a transaction with no fee payer or blockhash
  let tx = builder.build();

  // feed transaction into TransactionWrapper
  const wrapper = await TransactionWrapper.create({
    connectionManager: cm,
    transaction: tx,
    signer: sender.publicKey,
  }).addBlockhashAndFeePayer();

  // sign the transaction
  const signedTx = await wrapper.sign({
    signer: sender as Signer,
  });

  // send and confirm the transaction
  const transferSig = await wrapper.sendAndConfirm({
    serialisedTx: signedTx.serialize(),
  });
})();

Send a memo to 1 user

import { Keypair, LAMPORTS_PER_SOL, Signer } from "@solana/web3.js";
import {
  ConnectionManager,
  TransactionBuilder,
  TransactionWrapper,
  Logger
} from "@solworks/soltoolkit-sdk";

const logger = new Logger("example");
const sender = Keypair.generate();
const receiver = Keypair.generate();

(async () => {
  // create connection manager
  const cm = await ConnectionManager.getInstance({
    commitment: COMMITMENT,
    endpoints: [
      "https://api.devnet.solana.com",
      "https://solana-devnet-rpc.allthatnode.com",
      "https://mango.devnet.rpcpool.com",
      "https://rpc.ankr.com/solana_devnet",
    ],
    mode: "fastest",
    network: "devnet",
  });

  // airdrop sol to the generated address
  const airdropSig = await cm
    .connSync({ airdrop: true })
    .requestAirdrop(sender.publicKey, LAMPORTS_PER_SOL);

  // confirm airdrop tx
  await TransactionWrapper.confirmTx({
    connectionManager: cm,
    changeConn: false,
    signature: airdropSig,
    commitment: "max",
  });

  // create builder and add token transfer ix
  var builder = TransactionBuilder
    .create()
    .addMemoIx({
      memo: "gm",
      signer: sender.publicKey,
    });

  // build the transaction
  // returns a transaction with no fee payer or blockhash
  let tx = builder.build();

  // feed transaction into TransactionWrapper
  const wrapper = await TransactionWrapper.create({
    connectionManager: cm,
    transaction: tx,
    signer: sender.publicKey,
  }).addBlockhashAndFeePayer();

  // sign the transaction
  const signedTx = await wrapper.sign({
    signer: sender as Signer,
  });

  // send and confirm the transaction
  const transferSig = await wrapper.sendAndConfirm({
    serialisedTx: signedTx.serialize(),
  });

Lookup address for .sol domains

import { PublicKey } from "@solana/web3.js";
import {
    SNSDomainResolver,
    Logger
} from "@solworks/soltoolkit-sdk";

const logger = new Logger("example");
const addressString = '5F6gcdzpw7wUjNEugdsD4aLJdEQ4Wt8d6E85vaQXZQSJ';
const addressPublicKey = new PublicKey(addressString);

(async () => {
    // use the SNSDomainResolver to get the first .sol domain associated with an address
    // getDomainFromAddress takes a PublicKey or an address string as an argument
    // getDomainFromAddress returns a Promise<string | null>
    const firstDomainPk = await SNSDomainResolver.getDomainFromAddress(addressPublicKey);
    logger.info(`First domain for address: ${firstDomainPk || "no domain found"}`);
    const firstDomainString = await SNSDomainResolver.getDomainFromAddress(addressString);
    logger.info(`First domain for address: ${firstDomainString || "no domain found"}`);

    // use the SNSDomainResolver to get all .sol domains associated with an address
    // getDomainsFromAddress takes a PublicKey or an address string as an argument
    // getDomainsFromAddress returns a Promise<string[] | null>
    const allDomainsPk = await SNSDomainResolver.getDomainsFromAddress(addressPublicKey);
    logger.info(`All domains for address: ${allDomainsPk || "no domains found"}`);
    const allDomainsString = await SNSDomainResolver.getDomainsFromAddress(addressString);
    logger.info(`All domains for address: ${allDomainsString || "no domains found"}`);
})();

Send a transaction using Jito

import { Keypair, LAMPORTS_PER_SOL, Signer } from "@solana/web3.js";
import {
  ConnectionManager,
  TransactionBuilder,
  TransactionWrapper,
  Logger,
  sendTxUsingJito
} from "@solworks/soltoolkit-sdk";

(async () => {
  // create connection manager
  const cm = await ConnectionManager.getInstance({
    commitment: 'processed',
    endpoints: [
      "https://api.mainnet-beta.solana.com",
    ],
    mode: "fastest",
    network: "mainnet-beta",
  });

  // create builder and add token transfer ix
  var builder = TransactionBuilder
    .create()
    .addMemoIx({
      memo: "gm",
      signer: sender.publicKey,
    });

  // build the transaction
  // returns a transaction with no fee payer or blockhash
  let tx = builder.build();

  // feed transaction into TransactionWrapper
  const wrapper = await TransactionWrapper.create({
    connectionManager: cm,
    transaction: tx,
    signer: sender.publicKey,
  }).addBlockhashAndFeePayer();

  // sign the transaction
  const signedTx = await wrapper.sign({
    signer: sender as Signer,
  });

  // send and confirm the transaction
  const transferSig = await wrapper.sendTxUsingJito({
    serialisedTx: signedTx.serialize(),
    region: 'mainnet',
    sendOptions: {}
  });

  // OR use static method
  const transferSig = await sendTxUsingJito({
    serialisedTx: signedTx.serialize(),
    region: 'mainnet',
    sendOptions: {}
  });
})();

Dispersing SOL to 10,000 users in <120 seconds

See example.

License

SolToolkit is licensed under Affero GPL.