@solana/web3.js 0.0.0-next

package/src/loader.ts

@@ -0,0 +1,236 @@
+import {Buffer} from 'buffer';
+import * as BufferLayout from '@solana/buffer-layout';
+
+import {PublicKey} from './publickey';
+import {Transaction, PACKET_DATA_SIZE} from './transaction';
+import {SYSVAR_RENT_PUBKEY} from './sysvar';
+import {sendAndConfirmTransaction} from './util/send-and-confirm-transaction';
+import {sleep} from './util/sleep';
+import type {Connection} from './connection';
+import type {Signer} from './keypair';
+import {SystemProgram} from './system-program';
+import {IInstructionInputData} from './instruction';
+
+// Keep program chunks under PACKET_DATA_SIZE, leaving enough room for the
+// rest of the Transaction fields
+//
+// TODO: replace 300 with a proper constant for the size of the other
+// Transaction fields
+const CHUNK_SIZE = PACKET_DATA_SIZE - 300;
+
+/**
+ * Program loader interface
+ */
+export class Loader {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Amount of program data placed in each load Transaction
+   */
+  static chunkSize: number = CHUNK_SIZE;
+
+  /**
+   * Minimum number of signatures required to load a program not including
+   * retries
+   *
+   * Can be used to calculate transaction fees
+   */
+  static getMinNumSignatures(dataLength: number): number {
+    return (
+      2 * // Every transaction requires two signatures (payer + program)
+      (Math.ceil(dataLength / Loader.chunkSize) +
+        1 + // Add one for Create transaction
+        1) // Add one for Finalize transaction
+    );
+  }
+
+  /**
+   * Loads a generic program
+   *
+   * @param connection The connection to use
+   * @param payer System account that pays to load the program
+   * @param program Account to load the program into
+   * @param programId Public key that identifies the loader
+   * @param data Program octets
+   * @return true if program was loaded successfully, false if program was already loaded
+   */
+  static async load(
+    connection: Connection,
+    payer: Signer,
+    program: Signer,
+    programId: PublicKey,
+    data: Buffer | Uint8Array | Array<number>,
+  ): Promise<boolean> {
+    {
+      const balanceNeeded = await connection.getMinimumBalanceForRentExemption(
+        data.length,
+      );
+
+      // Fetch program account info to check if it has already been created
+      const programInfo = await connection.getAccountInfo(
+        program.publicKey,
+        'confirmed',
+      );
+
+      let transaction: Transaction | null = null;
+      if (programInfo !== null) {
+        if (programInfo.executable) {
+          console.error('Program load failed, account is already executable');
+          return false;
+        }
+
+        if (programInfo.data.length !== data.length) {
+          transaction = transaction || new Transaction();
+          transaction.add(
+            SystemProgram.allocate({
+              accountPubkey: program.publicKey,
+              space: data.length,
+            }),
+          );
+        }
+
+        if (!programInfo.owner.equals(programId)) {
+          transaction = transaction || new Transaction();
+          transaction.add(
+            SystemProgram.assign({
+              accountPubkey: program.publicKey,
+              programId,
+            }),
+          );
+        }
+
+        if (programInfo.lamports < balanceNeeded) {
+          transaction = transaction || new Transaction();
+          transaction.add(
+            SystemProgram.transfer({
+              fromPubkey: payer.publicKey,
+              toPubkey: program.publicKey,
+              lamports: balanceNeeded - programInfo.lamports,
+            }),
+          );
+        }
+      } else {
+        transaction = new Transaction().add(
+          SystemProgram.createAccount({
+            fromPubkey: payer.publicKey,
+            newAccountPubkey: program.publicKey,
+            lamports: balanceNeeded > 0 ? balanceNeeded : 1,
+            space: data.length,
+            programId,
+          }),
+        );
+      }
+
+      // If the account is already created correctly, skip this step
+      // and proceed directly to loading instructions
+      if (transaction !== null) {
+        await sendAndConfirmTransaction(
+          connection,
+          transaction,
+          [payer, program],
+          {
+            commitment: 'confirmed',
+          },
+        );
+      }
+    }
+
+    const dataLayout = BufferLayout.struct<
+      Readonly<{
+        bytes: number[];
+        bytesLength: number;
+        bytesLengthPadding: number;
+        instruction: number;
+        offset: number;
+      }>
+    >([
+      BufferLayout.u32('instruction'),
+      BufferLayout.u32('offset'),
+      BufferLayout.u32('bytesLength'),
+      BufferLayout.u32('bytesLengthPadding'),
+      BufferLayout.seq(
+        BufferLayout.u8('byte'),
+        BufferLayout.offset(BufferLayout.u32(), -8),
+        'bytes',
+      ),
+    ]);
+
+    const chunkSize = Loader.chunkSize;
+    let offset = 0;
+    let array = data;
+    let transactions = [];
+    while (array.length > 0) {
+      const bytes = array.slice(0, chunkSize);
+      const data = Buffer.alloc(chunkSize + 16);
+      dataLayout.encode(
+        {
+          instruction: 0, // Load instruction
+          offset,
+          bytes: bytes as number[],
+          bytesLength: 0,
+          bytesLengthPadding: 0,
+        },
+        data,
+      );
+
+      const transaction = new Transaction().add({
+        keys: [{pubkey: program.publicKey, isSigner: true, isWritable: true}],
+        programId,
+        data,
+      });
+      transactions.push(
+        sendAndConfirmTransaction(connection, transaction, [payer, program], {
+          commitment: 'confirmed',
+        }),
+      );
+
+      // Delay between sends in an attempt to reduce rate limit errors
+      if (connection._rpcEndpoint.includes('solana.com')) {
+        const REQUESTS_PER_SECOND = 4;
+        await sleep(1000 / REQUESTS_PER_SECOND);
+      }
+
+      offset += chunkSize;
+      array = array.slice(chunkSize);
+    }
+    await Promise.all(transactions);
+
+    // Finalize the account loaded with program data for execution
+    {
+      const dataLayout = BufferLayout.struct<IInstructionInputData>([
+        BufferLayout.u32('instruction'),
+      ]);
+
+      const data = Buffer.alloc(dataLayout.span);
+      dataLayout.encode(
+        {
+          instruction: 1, // Finalize instruction
+        },
+        data,
+      );
+
+      const transaction = new Transaction().add({
+        keys: [
+          {pubkey: program.publicKey, isSigner: true, isWritable: true},
+          {pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
+        ],
+        programId,
+        data,
+      });
+      await sendAndConfirmTransaction(
+        connection,
+        transaction,
+        [payer, program],
+        {
+          commitment: 'confirmed',
+        },
+      );
+    }
+
+    // success
+    return true;
+  }
+}

package/src/message.ts

@@ -0,0 +1,271 @@
+import bs58 from 'bs58';
+import {Buffer} from 'buffer';
+import * as BufferLayout from '@solana/buffer-layout';
+
+import {PublicKey} from './publickey';
+import type {Blockhash} from './blockhash';
+import * as Layout from './layout';
+import {PACKET_DATA_SIZE} from './transaction';
+import * as shortvec from './util/shortvec-encoding';
+import {toBuffer} from './util/to-buffer';
+
+/**
+ * The message header, identifying signed and read-only account
+ */
+export type MessageHeader = {
+  /**
+   * The number of signatures required for this message to be considered valid. The
+   * signatures must match the first `numRequiredSignatures` of `accountKeys`.
+   */
+  numRequiredSignatures: number;
+  /** The last `numReadonlySignedAccounts` of the signed keys are read-only accounts */
+  numReadonlySignedAccounts: number;
+  /** The last `numReadonlySignedAccounts` of the unsigned keys are read-only accounts */
+  numReadonlyUnsignedAccounts: number;
+};
+
+/**
+ * An instruction to execute by a program
+ *
+ * @property {number} programIdIndex
+ * @property {number[]} accounts
+ * @property {string} data
+ */
+export type CompiledInstruction = {
+  /** Index into the transaction keys array indicating the program account that executes this instruction */
+  programIdIndex: number;
+  /** Ordered indices into the transaction keys array indicating which accounts to pass to the program */
+  accounts: number[];
+  /** The program input data encoded as base 58 */
+  data: string;
+};
+
+/**
+ * Message constructor arguments
+ */
+export type MessageArgs = {
+  /** The message header, identifying signed and read-only `accountKeys` */
+  header: MessageHeader;
+  /** All the account keys used by this transaction */
+  accountKeys: string[];
+  /** The hash of a recent ledger block */
+  recentBlockhash: Blockhash;
+  /** Instructions that will be executed in sequence and committed in one atomic transaction if all succeed. */
+  instructions: CompiledInstruction[];
+};
+
+const PUBKEY_LENGTH = 32;
+
+/**
+ * List of instructions to be processed atomically
+ */
+export class Message {
+  header: MessageHeader;
+  accountKeys: PublicKey[];
+  recentBlockhash: Blockhash;
+  instructions: CompiledInstruction[];
+
+  private indexToProgramIds: Map<number, PublicKey> = new Map<
+    number,
+    PublicKey
+  >();
+
+  constructor(args: MessageArgs) {
+    this.header = args.header;
+    this.accountKeys = args.accountKeys.map(account => new PublicKey(account));
+    this.recentBlockhash = args.recentBlockhash;
+    this.instructions = args.instructions;
+    this.instructions.forEach(ix =>
+      this.indexToProgramIds.set(
+        ix.programIdIndex,
+        this.accountKeys[ix.programIdIndex],
+      ),
+    );
+  }
+
+  isAccountSigner(index: number): boolean {
+    return index < this.header.numRequiredSignatures;
+  }
+
+  isAccountWritable(index: number): boolean {
+    return (
+      index <
+        this.header.numRequiredSignatures -
+          this.header.numReadonlySignedAccounts ||
+      (index >= this.header.numRequiredSignatures &&
+        index <
+          this.accountKeys.length - this.header.numReadonlyUnsignedAccounts)
+    );
+  }
+
+  isProgramId(index: number): boolean {
+    return this.indexToProgramIds.has(index);
+  }
+
+  programIds(): PublicKey[] {
+    return [...this.indexToProgramIds.values()];
+  }
+
+  nonProgramIds(): PublicKey[] {
+    return this.accountKeys.filter((_, index) => !this.isProgramId(index));
+  }
+
+  serialize(): Buffer {
+    const numKeys = this.accountKeys.length;
+
+    let keyCount: number[] = [];
+    shortvec.encodeLength(keyCount, numKeys);
+
+    const instructions = this.instructions.map(instruction => {
+      const {accounts, programIdIndex} = instruction;
+      const data = Array.from(bs58.decode(instruction.data));
+
+      let keyIndicesCount: number[] = [];
+      shortvec.encodeLength(keyIndicesCount, accounts.length);
+
+      let dataCount: number[] = [];
+      shortvec.encodeLength(dataCount, data.length);
+
+      return {
+        programIdIndex,
+        keyIndicesCount: Buffer.from(keyIndicesCount),
+        keyIndices: accounts,
+        dataLength: Buffer.from(dataCount),
+        data,
+      };
+    });
+
+    let instructionCount: number[] = [];
+    shortvec.encodeLength(instructionCount, instructions.length);
+    let instructionBuffer = Buffer.alloc(PACKET_DATA_SIZE);
+    Buffer.from(instructionCount).copy(instructionBuffer);
+    let instructionBufferLength = instructionCount.length;
+
+    instructions.forEach(instruction => {
+      const instructionLayout = BufferLayout.struct<
+        Readonly<{
+          data: number[];
+          dataLength: Uint8Array;
+          keyIndices: number[];
+          keyIndicesCount: Uint8Array;
+          programIdIndex: number;
+        }>
+      >([
+        BufferLayout.u8('programIdIndex'),
+
+        BufferLayout.blob(
+          instruction.keyIndicesCount.length,
+          'keyIndicesCount',
+        ),
+        BufferLayout.seq(
+          BufferLayout.u8('keyIndex'),
+          instruction.keyIndices.length,
+          'keyIndices',
+        ),
+        BufferLayout.blob(instruction.dataLength.length, 'dataLength'),
+        BufferLayout.seq(
+          BufferLayout.u8('userdatum'),
+          instruction.data.length,
+          'data',
+        ),
+      ]);
+      const length = instructionLayout.encode(
+        instruction,
+        instructionBuffer,
+        instructionBufferLength,
+      );
+      instructionBufferLength += length;
+    });
+    instructionBuffer = instructionBuffer.slice(0, instructionBufferLength);
+
+    const signDataLayout = BufferLayout.struct<
+      Readonly<{
+        keyCount: Uint8Array;
+        keys: Uint8Array[];
+        numReadonlySignedAccounts: Uint8Array;
+        numReadonlyUnsignedAccounts: Uint8Array;
+        numRequiredSignatures: Uint8Array;
+        recentBlockhash: Uint8Array;
+      }>
+    >([
+      BufferLayout.blob(1, 'numRequiredSignatures'),
+      BufferLayout.blob(1, 'numReadonlySignedAccounts'),
+      BufferLayout.blob(1, 'numReadonlyUnsignedAccounts'),
+      BufferLayout.blob(keyCount.length, 'keyCount'),
+      BufferLayout.seq(Layout.publicKey('key'), numKeys, 'keys'),
+      Layout.publicKey('recentBlockhash'),
+    ]);
+
+    const transaction = {
+      numRequiredSignatures: Buffer.from([this.header.numRequiredSignatures]),
+      numReadonlySignedAccounts: Buffer.from([
+        this.header.numReadonlySignedAccounts,
+      ]),
+      numReadonlyUnsignedAccounts: Buffer.from([
+        this.header.numReadonlyUnsignedAccounts,
+      ]),
+      keyCount: Buffer.from(keyCount),
+      keys: this.accountKeys.map(key => toBuffer(key.toBytes())),
+      recentBlockhash: bs58.decode(this.recentBlockhash),
+    };
+
+    let signData = Buffer.alloc(2048);
+    const length = signDataLayout.encode(transaction, signData);
+    instructionBuffer.copy(signData, length);
+    return signData.slice(0, length + instructionBuffer.length);
+  }
+
+  /**
+   * Decode a compiled message into a Message object.
+   */
+  static from(buffer: Buffer | Uint8Array | Array<number>): Message {
+    // Slice up wire data
+    let byteArray = [...buffer];
+
+    const numRequiredSignatures = byteArray.shift() as number;
+    const numReadonlySignedAccounts = byteArray.shift() as number;
+    const numReadonlyUnsignedAccounts = byteArray.shift() as number;
+
+    const accountCount = shortvec.decodeLength(byteArray);
+    let accountKeys = [];
+    for (let i = 0; i < accountCount; i++) {
+      const account = byteArray.slice(0, PUBKEY_LENGTH);
+      byteArray = byteArray.slice(PUBKEY_LENGTH);
+      accountKeys.push(bs58.encode(Buffer.from(account)));
+    }
+
+    const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
+    byteArray = byteArray.slice(PUBKEY_LENGTH);
+
+    const instructionCount = shortvec.decodeLength(byteArray);
+    let instructions: CompiledInstruction[] = [];
+    for (let i = 0; i < instructionCount; i++) {
+      const programIdIndex = byteArray.shift() as number;
+      const accountCount = shortvec.decodeLength(byteArray);
+      const accounts = byteArray.slice(0, accountCount);
+      byteArray = byteArray.slice(accountCount);
+      const dataLength = shortvec.decodeLength(byteArray);
+      const dataSlice = byteArray.slice(0, dataLength);
+      const data = bs58.encode(Buffer.from(dataSlice));
+      byteArray = byteArray.slice(dataLength);
+      instructions.push({
+        programIdIndex,
+        accounts,
+        data,
+      });
+    }
+
+    const messageArgs = {
+      header: {
+        numRequiredSignatures,
+        numReadonlySignedAccounts,
+        numReadonlyUnsignedAccounts,
+      },
+      recentBlockhash: bs58.encode(Buffer.from(recentBlockhash)),
+      accountKeys,
+      instructions,
+    };
+
+    return new Message(messageArgs);
+  }
+}

package/src/nonce-account.ts

@@ -0,0 +1,78 @@
+import * as BufferLayout from '@solana/buffer-layout';
+import {Buffer} from 'buffer';
+
+import type {Blockhash} from './blockhash';
+import * as Layout from './layout';
+import {PublicKey} from './publickey';
+import type {FeeCalculator} from './fee-calculator';
+import {FeeCalculatorLayout} from './fee-calculator';
+import {toBuffer} from './util/to-buffer';
+
+/**
+ * See https://github.com/solana-labs/solana/blob/0ea2843ec9cdc517572b8e62c959f41b55cf4453/sdk/src/nonce_state.rs#L29-L32
+ *
+ * @internal
+ */
+const NonceAccountLayout = BufferLayout.struct<
+  Readonly<{
+    authorizedPubkey: Uint8Array;
+    feeCalculator: Readonly<{
+      lamportsPerSignature: number;
+    }>;
+    nonce: Uint8Array;
+    state: number;
+    version: number;
+  }>
+>([
+  BufferLayout.u32('version'),
+  BufferLayout.u32('state'),
+  Layout.publicKey('authorizedPubkey'),
+  Layout.publicKey('nonce'),
+  BufferLayout.struct<Readonly<{lamportsPerSignature: number}>>(
+    [FeeCalculatorLayout],
+    'feeCalculator',
+  ),
+]);
+
+export const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;
+
+type NonceAccountArgs = {
+  authorizedPubkey: PublicKey;
+  nonce: Blockhash;
+  feeCalculator: FeeCalculator;
+};
+
+/**
+ * NonceAccount class
+ */
+export class NonceAccount {
+  authorizedPubkey: PublicKey;
+  nonce: Blockhash;
+  feeCalculator: FeeCalculator;
+
+  /**
+   * @internal
+   */
+  constructor(args: NonceAccountArgs) {
+    this.authorizedPubkey = args.authorizedPubkey;
+    this.nonce = args.nonce;
+    this.feeCalculator = args.feeCalculator;
+  }
+
+  /**
+   * Deserialize NonceAccount from the account data.
+   *
+   * @param buffer account data
+   * @return NonceAccount
+   */
+  static fromAccountData(
+    buffer: Buffer | Uint8Array | Array<number>,
+  ): NonceAccount {
+    const nonceAccount = NonceAccountLayout.decode(toBuffer(buffer), 0);
+    return new NonceAccount({
+      authorizedPubkey: new PublicKey(nonceAccount.authorizedPubkey),
+      nonce: new PublicKey(nonceAccount.nonce).toString(),
+      feeCalculator: nonceAccount.feeCalculator,
+    });
+  }
+}