loader.js

const { Buffer } = require("buffer");
const BufferLayout = require("@solana/buffer-layout");

const {
  PublicKey,
  Transaction,
  SYSVAR_RENT_PUBKEY,
  SYSVAR_CLOCK_PUBKEY,
  sendAndConfirmTransaction,
  SystemProgram,
  Account,
  TransactionInstruction,
} = require("@solana/web3.js");

const UPGRADEABLE_BPF_LOADER_PROGRAM_ID = new PublicKey(
  "BPFLoaderUpgradeab1e11111111111111111111111",
);

// Keep program chunks under PACKET_DATA_SIZE, leaving enough room for the
// rest of the Transaction fields
const CHUNK_SIZE = 900;

function encodeInstruction(data) {
  const dataLayout = BufferLayout.union(BufferLayout.u32("tag"), null, "tag");
  dataLayout.addVariant(0, BufferLayout.struct([]), "InitializeBuffer");
  const write = BufferLayout.struct([
    BufferLayout.u32("offset"),
    BufferLayout.nu64("length"),
    BufferLayout.seq(
      BufferLayout.u8("byte"),
      BufferLayout.offset(BufferLayout.u32(), -8),
      "bytes",
    ),
  ]);
  dataLayout.addVariant(1, write, "Write");
  const deployWithMaxLen = BufferLayout.struct([
    BufferLayout.nu64("max_data_len"),
  ]);
  dataLayout.addVariant(2, deployWithMaxLen, "DeployWithMaxDataLen");
  dataLayout.addVariant(3, BufferLayout.struct([]), "Upgrade");
  dataLayout.addVariant(4, BufferLayout.struct([]), "SetAuthority");
  dataLayout.addVariant(5, BufferLayout.struct([]), "Close");
  const extendProgram = BufferLayout.struct([
    BufferLayout.u32("additional_bytes"),
  ]);
  dataLayout.addVariant(6, extendProgram, "ExtendProgram");
  const extendProgramChecked = BufferLayout.struct([
    BufferLayout.u32("additional_bytes"),
  ]);
  dataLayout.addVariant(9, extendProgramChecked, "ExtendProgramChecked");

  // UpgradeableLoaderInstruction tag + offset + chunk length + chunk data
  const instructionBuffer = Buffer.alloc(4 + 4 + 8 + Loader.chunkSize);
  const encodedSize = dataLayout.encode(data, instructionBuffer);
  return instructionBuffer.slice(0, encodedSize);
}

/**
 * Program loader interface
 */
class Loader {
  /**
   * Amount of program data placed in each load Transaction
   */
  static chunkSize = CHUNK_SIZE;

  /**
   * Minimum number of signatures required to load a program not including
   * retries
   *
   * Can be used to calculate transaction fees
   */
  static getMinNumSignatures(dataLength) {
    return (
      // Add one for Finalize transaction
      2 * // Every transaction requires two signatures (payer + program)
      (Math.ceil(dataLength / Loader.chunkSize) +
        1 + // Add one for Create transaction
        1)
    );
  }

  static async deploy(connection, payer, program, authority, data) {
    const buffer = new Account();
    await initBuffer(connection, payer, authority, data, buffer);

    await produceWriteTransactions(
      authority,
      data,
      buffer,
      async (transaction, offset) => {
        await sendAndConfirmTransaction(
          connection,
          transaction,
          [payer, authority],
          {
            commitment: "confirmed",
          },
        );
        console.log("write progress:", offset, "/", data.length);
      },
    );

    console.log("buffer write complete");

    await deployBuffer(connection, payer, program, authority, data, buffer);

    return true;
  }

  static async deployAsync(connection, payer, program, authority, data) {
    const buffer = new Account();
    await initBuffer(connection, payer, authority, data, buffer);

    const signatures_promises = [];
    await produceWriteTransactions(
      authority,
      data,
      buffer,
      async (transaction, _offset) => {
        signatures_promises.push(
          connection.sendTransaction(transaction, [payer, authority], {
            preflightCommitment: "processed",
          }),
        );
        await Promise.resolve();
      },
    );

    const signatures = await Promise.all(signatures_promises);
    console.log("transactions were sent");
    const confirmations = [];
    for (const signature of signatures) {
      confirmations.push(connection.confirmTransaction(signature, "confirmed"));
    }
    await Promise.all(confirmations);
    console.log("transactions were confirmed;buffer write complete");

    await deployBuffer(connection, payer, program, authority, data, buffer);

    return true;
  }

  static async upgradeInstruction(program, buffer, spillAddress, authority) {
    const [programDataKey, _nonce] = PublicKey.findProgramAddressSync(
      [program.toBuffer()],
      UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
    );

    return new TransactionInstruction({
      keys: [
        { pubkey: programDataKey, isSigner: false, isWritable: true },
        { pubkey: program, isSigner: false, isWritable: true },
        { pubkey: buffer, isSigner: false, isWritable: true },
        { pubkey: spillAddress, isSigner: false, isWritable: true },
        { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
        { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
        { pubkey: authority, isSigner: true, isWritable: false },
      ],
      programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
      data: encodeInstruction({ Upgrade: {} }),
    });
  }

  static async setUpgradeAuthorityInstruction(
    program,
    currentAuthority,
    newAuthority,
  ) {
    const [programDataKey, _nonce] = PublicKey.findProgramAddressSync(
      [program.toBuffer()],
      UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
    );
    return new TransactionInstruction({
      keys: [
        { pubkey: programDataKey, isSigner: false, isWritable: true },
        { pubkey: currentAuthority, isSigner: true, isWritable: false },
        { pubkey: newAuthority, isSigner: false, isWritable: false },
      ],
      programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
      data: encodeInstruction({ SetAuthority: {} }),
    });
  }

  static async extendProgramInstruction(program, payer, additionalBytes) {
    const [programDataKey, _nonce] = PublicKey.findProgramAddressSync(
      [program.toBuffer()],
      UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
    );
    return new TransactionInstruction({
      keys: [
        { pubkey: programDataKey, isSigner: false, isWritable: true },
        { pubkey: program, isSigner: false, isWritable: true },
        {
          pubkey: SystemProgram.programId,
          isSigner: false,
          isWritable: false,
        },
        { pubkey: payer, isSigner: true, isWritable: true },
      ],
      programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
      data: encodeInstruction({
        ExtendProgram: { additional_bytes: additionalBytes },
      }),
    });
  }

  static async extendProgramCheckedInstruction(
    program,
    authority,
    payer,
    additionalBytes,
  ) {
    const [programDataKey, _nonce] = PublicKey.findProgramAddressSync(
      [program.toBuffer()],
      UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
    );
    return new TransactionInstruction({
      keys: [
        { pubkey: programDataKey, isSigner: false, isWritable: true },
        { pubkey: program, isSigner: false, isWritable: true },
        { pubkey: authority, isSigner: true, isWritable: false },
        {
          pubkey: SystemProgram.programId,
          isSigner: false,
          isWritable: false,
        },
        { pubkey: payer, isSigner: true, isWritable: true },
      ],
      programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
      data: encodeInstruction({
        ExtendProgramChecked: { additional_bytes: additionalBytes },
      }),
    });
  }

  static async getDeployBufferTransaction(
    connection,
    payer,
    data,
    program,
    bufferAccount,
    authority,
  ) {
    const programSpace = 36; // UpgradeableLoaderState::program_len()
    const programBalanceNeeded =
      await connection.getMinimumBalanceForRentExemption(programSpace);
    const [programDataKey, _nonce] = PublicKey.findProgramAddressSync(
      [program.toBuffer()],
      UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
    );

    const deployTransaction = new Transaction()
      .add(
        SystemProgram.createAccount({
          fromPubkey: payer,
          newAccountPubkey: program,
          lamports: programBalanceNeeded,
          space: programSpace,
          programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
        }),
      )
      .add(
        new TransactionInstruction({
          keys: [
            { pubkey: payer, isSigner: true, isWritable: true },
            { pubkey: programDataKey, isSigner: false, isWritable: true },
            { pubkey: program, isSigner: false, isWritable: true },
            {
              pubkey: bufferAccount,
              isSigner: false,
              isWritable: true,
            },

            { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
            { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
            {
              pubkey: SystemProgram.programId,
              isSigner: false,
              isWritable: false,
            },
            { pubkey: authority, isSigner: true, isWritable: false },
          ],
          programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
          data: encodeInstruction({
            DeployWithMaxDataLen: { max_data_len: data.length * 3 },
          }),
        }),
      );
    return deployTransaction;
  }
}

async function initBuffer(connection, payer, authority, data, bufferAccount) {
  console.log("buffer account", bufferAccount.publicKey.toBase58());
  console.log("authority account", authority.publicKey.toBase58());
  // UpgradeableLoaderState::buffer_len(program_len) = 37 + program_len
  const bufferSpace = 37 + data.length;
  const balanceNeeded =
    await connection.getMinimumBalanceForRentExemption(bufferSpace);

  const initTransaction = new Transaction()
    .add(
      SystemProgram.createAccount({
        fromPubkey: payer.publicKey,
        newAccountPubkey: bufferAccount.publicKey,
        lamports: balanceNeeded,
        space: bufferSpace,
        programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
      }),
    )
    .add(
      new TransactionInstruction({
        keys: [
          {
            pubkey: bufferAccount.publicKey,
            isSigner: false,
            isWritable: true,
          },
          { pubkey: authority.publicKey, isSigner: false, isWritable: false },
        ],
        programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
        data: encodeInstruction({ InitializeBuffer: {} }),
      }),
    );
  await sendAndConfirmTransaction(
    connection,
    initTransaction,
    [payer, bufferAccount],
    {
      commitment: "confirmed",
    },
  );
  console.log("program buffer initialized");
}

// transactionProcessor takes produced transactions and perform operations on them.
// For example async deploy takes and stores then in an array,
// while sync deploy awaits for confirmations on them serially.
async function produceWriteTransactions(
  authority,
  data,
  bufferAccount,
  transactionProcessor,
) {
  const chunkSize = Loader.chunkSize;
  let offset = 0;
  let array = data;
  while (array.length > 0) {
    const bytes = array.slice(0, Loader.chunkSize);
    const transaction = new Transaction().add({
      keys: [
        { pubkey: bufferAccount.publicKey, isSigner: false, isWritable: true },
        { pubkey: authority.publicKey, isSigner: true, isWritable: false },
      ],
      programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
      data: encodeInstruction({
        Write: {
          offset,
          bytes,
        },
      }),
    });
    await transactionProcessor(transaction, offset);

    offset += chunkSize;
    array = array.slice(chunkSize);
  }
  console.log("buffer write complete");
}

async function deployBuffer(
  connection,
  payer,
  program,
  authority,
  data,
  bufferAccount,
) {
  const deployTransaction = await Loader.getDeployBufferTransaction(
    connection,
    payer.publicKey,
    data,
    program.publicKey,
    bufferAccount.publicKey,
    authority.publicKey,
  );

  await sendAndConfirmTransaction(
    connection,
    deployTransaction,
    [payer, program, authority],
    {
      commitment: "confirmed",
    },
  );
}

module.exports = Loader;