⛽Scale by Solana at Solana

Dispersing SOL to 10,000 users in <120 seconds

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

const COMMITMENT: Commitment = "confirmed"; const NO_OF_RECEIVERS = 10_000; const CHUNK_SIZE = 30; const TOTAL_SOL = 10;

const SKIP_AIRDROP = true; const SKIP_SENDING = false; const SKIP_BALANCE_CHECK = true;

// generate keypair for example const sender = Keypair.fromSecretKey( Uint8Array.from([ 36, 50, 153, 146, 147, 239, 210, 72, 199, 68, 75, 220, 42, 139, 105, 61, 148, 117, 55, 75, 23, 144, 30, 206, 138, 255, 51, 206, 102, 239, 73, 28, 240, 73, 69, 190, 238, 27, 112, 36, 151, 255, 182, 64, 13, 173, 94, 115, 111, 45, 2, 154, 250, 93, 100, 44, 251, 111, 229, 34, 193, 249, 199, 238, ]) );

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

// create connection manager const cm = await ConnectionManager.getInstance({ commitment: COMMITMENT, endpoints: [ "https://mango.devnet.rpcpool.com",

  // https://docs.solana.com/cluster/rpc-endpoints
  // Maximum number of requests per 10 seconds per IP: 100 (10/s)
  // Maximum number of requests per 10 seconds per IP for a single RPC: 40 (4/s)
  // Maximum concurrent connections per IP: 40
  // Maximum connection rate per 10 seconds per IP: 40
  // Maximum amount of data per 30 second: 100 MB
  // "https://api.devnet.solana.com",

  // https://shdw.genesysgo.com/genesysgo/the-genesysgo-rpc-network
  // SendTransaction Limit: 10 RPS + 200 Burst
  // getProgramAccounts Limit: 15 RPS + 5 burst
  // Global Limit on the rest of the calls: 200 RPS
  "https://devnet.genesysgo.net",
],
mode: "round-robin",
network: "devnet",

});

if (!SKIP_AIRDROP) { // airdrop 1 sol to new addresses, confirm and send sol to SENDER for (let i = 0; i < Math.ceil((TOTAL_SOL + 1) / 1); i++) { // generate new keypair const keypair = Keypair.generate();

  // airdrop sol to the generated address
  const airdropSig = await cm
    .connSync({ airdrop: true })
    .requestAirdrop(keypair.publicKey, LAMPORTS_PER_SOL);
  logger.debug("Airdropped 1 SOL to", sender.publicKey.toBase58());

  // wait for confirmation
  logger.debug("Confirming airdrop transaction...");
  await TransactionWrapper.confirmTx({
    connectionManager: cm,
    changeConn: false,
    signature: airdropSig,
    commitment: "max",
    airdrop: true,
  });
  logger.debug("Airdrop transaction confirmed");

  // send sol to SENDER
  const tx = TransactionBuilder.create()
    .addSolTransferIx({
      from: keypair.publicKey,
      to: sender.publicKey,
      amountLamports: LAMPORTS_PER_SOL - 5000,
    })
    .build();

  const wrapper = await TransactionWrapper.create({
    connectionManager: cm,
    changeConn: false,
    signer: keypair.publicKey,
    transaction: tx,
  }).addBlockhashAndFeePayer(keypair.publicKey);
  const signedTx = await wrapper.sign({ signer: keypair as Signer });
  const sig = await wrapper.sendAndConfirm({
    serialisedTx: signedTx.serialize(),
    commitment: "max",
  });
  logger.debug(
    "Sent 1 SOL to",
    sender.publicKey.toBase58(),
    "with signature",
    sig
  );

  await sleep(1000);
}

}

// fetch balance of the generated address logger.debug("Fetching balance of", sender.publicKey.toBase58()); let senderBal = await cm // default value for changeConn = true .connSync({ changeConn: true }) .getBalance(sender.publicKey, COMMITMENT); logger.debug(Sender balance: ${senderBal});

// generate receivers logger.debug(Generating ${NO_OF_RECEIVERS} receivers...); const receivers: Keypair[] = []; for (let i = 0; i < NO_OF_RECEIVERS; i++) { receivers.push(Keypair.generate()); } logger.debug("Receivers generated");

// generate transactions const transfers: { amount: number; recipient: string; }[] = [];

const rentCost = (NO_OF_RECEIVERS+1) * 5_000; const transferAmount = Math.floor( (senderBal - rentCost) / NO_OF_RECEIVERS ); logger.debug(Sending ${transferAmount} to ${NO_OF_RECEIVERS} receivers); for (let i = 0; i < NO_OF_RECEIVERS; i++) { transfers.push({ amount: transferAmount, recipient: receivers[i].publicKey.toBase58(), }); }

// send transactions if (!SKIP_SENDING) { const transactions = await Disperse.create({ tokenType: "SOL", sender: sender.publicKey, transfers, }).generateTransactions();

const txChunks = chunk(transactions, CHUNK_SIZE);
for (let i = 0; i < txChunks.length; i++) {
  logger.debug(`Sending transactions ${i + 1}/${txChunks.length}`);
  const txChunk = txChunks[i];
  const conn = cm.connSync({ changeConn: true });

  await Promise.all(
    txChunk.map(async (tx: Transaction, i: number) => {
      logger.debug(`Sending transaction ${i + 1}`);

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

      // sign the transaction
      logger.debug(`Signing transaction ${i + 1}`);
      const signedTx = await wrapper.sign({
        signer: sender as Signer,
      });

      // send and confirm the transaction
      logger.debug(`Sending transaction ${i + 1}`);
      const transferSig = await wrapper.sendAndConfirm({
        serialisedTx: signedTx.serialize(),
        commitment: COMMITMENT,
      });
      logger.debug("Transaction sent:", transferSig.toString());
    })
  );
  await sleep(1_000);
}

}

if (!SKIP_BALANCE_CHECK) { // fetch balance of the generated address logger.debug("Fetching balance of:", sender.publicKey.toBase58()); senderBal = await cm .connSync({ changeConn: true }) .getBalance(sender.publicKey, COMMITMENT); logger.debug(Sender balance: ${senderBal});

// split addresses into chunks of CHUNK_SIZE
const chunks = chunk(receivers, CHUNK_SIZE);
const balances: {
  balance: number;
  address: string;
}[] = [];
for (let i = 0; i < chunks.length; i++) {
  const chunk = chunks[i];
  logger.debug(
    `Fetching balances for chunk ${i + 1} with ${chunk.length} addresses`
  );

  // cycle to new connection to avoid rate limiting
  let conn = cm.connSync({ changeConn: true });

  // fetch balances
  const results = await Promise.all(
    chunk.map(async (receiver: Keypair) => {
      const balance = await conn.getBalance(receiver.publicKey, COMMITMENT);
      logger.debug(
        `Balance of ${receiver.publicKey.toBase58()}: ${balance}`
      );
      return {
        balance,
        address: receiver.publicKey.toBase58(),
      };
    })
  );

  // add results to balances
  balances.push(...results);
  await sleep(1_000);
}

const totalBalance = balances.reduce((acc, curr) => acc + curr.balance, 0);
const numberWithNoBalance = balances.filter((b) => b.balance === 0).length;
const numberWithBalance = balances.filter((b) => b.balance > 0).length;
logger.debug(`Total amount sent: ${totalBalance}`);
logger.debug(`Number of addresses with no balance: ${numberWithNoBalance}`);
logger.debug(`Number of addresses with balance: ${numberWithBalance}`);

} })();

function chunk(arr: any[], len: number) { var chunks: any[] = [], i = 0, n = arr.length;

while (i < n) { chunks.push(arr.slice(i, (i += len))); } return chunks; }

function sleep(ms: number) { return new Promise((resolve) => setTimeout(resolve, ms)); }