@solana/web3.js 1.77.3 → 2.0.0-development

package/src/loader.ts

@@ -1,267 +0,0 @@
-import {Buffer} from 'buffer';
-import * as BufferLayout from '@solana/buffer-layout';
-
-import {PublicKey} from './publickey';
-import {Transaction, PACKET_DATA_SIZE} from './transaction';
-import {MS_PER_SLOT} from './timing';
-import {SYSVAR_RENT_PUBKEY} from './sysvar';
-import {sendAndConfirmTransaction} from './utils/send-and-confirm-transaction';
-import {sleep} from './utils/sleep';
-import type {Connection} from './connection';
-import type {Signer} from './keypair';
-import {SystemProgram} from './programs/system';
-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,
-      });
-      const deployCommitment = 'processed';
-      const finalizeSignature = await connection.sendTransaction(
-        transaction,
-        [payer, program],
-        {preflightCommitment: deployCommitment},
-      );
-      const {context, value} = await connection.confirmTransaction(
-        {
-          signature: finalizeSignature,
-          lastValidBlockHeight: transaction.lastValidBlockHeight!,
-          blockhash: transaction.recentBlockhash!,
-        },
-        deployCommitment,
-      );
-      if (value.err) {
-        throw new Error(
-          `Transaction ${finalizeSignature} failed (${JSON.stringify(value)})`,
-        );
-      }
-      // We prevent programs from being usable until the slot after their deployment.
-      // See https://github.com/solana-labs/solana/pull/29654
-      while (
-        true // eslint-disable-line no-constant-condition
-      ) {
-        try {
-          const currentSlot = await connection.getSlot({
-            commitment: deployCommitment,
-          });
-          if (currentSlot > context.slot) {
-            break;
-          }
-        } catch {
-          /* empty */
-        }
-        await new Promise(resolve =>
-          setTimeout(resolve, Math.round(MS_PER_SLOT / 2)),
-        );
-      }
-    }
-
-    // success
-    return true;
-  }
-}

package/src/message/account-keys.ts

@@ -1,79 +0,0 @@
-import {LoadedAddresses} from '../connection';
-import {PublicKey} from '../publickey';
-import {TransactionInstruction} from '../transaction';
-import {MessageCompiledInstruction} from './index';
-
-export type AccountKeysFromLookups = LoadedAddresses;
-
-export class MessageAccountKeys {
-  staticAccountKeys: Array<PublicKey>;
-  accountKeysFromLookups?: AccountKeysFromLookups;
-
-  constructor(
-    staticAccountKeys: Array<PublicKey>,
-    accountKeysFromLookups?: AccountKeysFromLookups,
-  ) {
-    this.staticAccountKeys = staticAccountKeys;
-    this.accountKeysFromLookups = accountKeysFromLookups;
-  }
-
-  keySegments(): Array<Array<PublicKey>> {
-    const keySegments = [this.staticAccountKeys];
-    if (this.accountKeysFromLookups) {
-      keySegments.push(this.accountKeysFromLookups.writable);
-      keySegments.push(this.accountKeysFromLookups.readonly);
-    }
-    return keySegments;
-  }
-
-  get(index: number): PublicKey | undefined {
-    for (const keySegment of this.keySegments()) {
-      if (index < keySegment.length) {
-        return keySegment[index];
-      } else {
-        index -= keySegment.length;
-      }
-    }
-    return;
-  }
-
-  get length(): number {
-    return this.keySegments().flat().length;
-  }
-
-  compileInstructions(
-    instructions: Array<TransactionInstruction>,
-  ): Array<MessageCompiledInstruction> {
-    // Bail early if any account indexes would overflow a u8
-    const U8_MAX = 255;
-    if (this.length > U8_MAX + 1) {
-      throw new Error('Account index overflow encountered during compilation');
-    }
-
-    const keyIndexMap = new Map();
-    this.keySegments()
-      .flat()
-      .forEach((key, index) => {
-        keyIndexMap.set(key.toBase58(), index);
-      });
-
-    const findKeyIndex = (key: PublicKey) => {
-      const keyIndex = keyIndexMap.get(key.toBase58());
-      if (keyIndex === undefined)
-        throw new Error(
-          'Encountered an unknown instruction account key during compilation',
-        );
-      return keyIndex;
-    };
-
-    return instructions.map((instruction): MessageCompiledInstruction => {
-      return {
-        programIdIndex: findKeyIndex(instruction.programId),
-        accountKeyIndexes: instruction.keys.map(meta =>
-          findKeyIndex(meta.pubkey),
-        ),
-        data: instruction.data,
-      };
-    });
-  }
-}

package/src/message/compiled-keys.ts

@@ -1,165 +0,0 @@
-import {MessageHeader, MessageAddressTableLookup} from './index';
-import {AccountKeysFromLookups} from './account-keys';
-import {AddressLookupTableAccount} from '../programs';
-import {TransactionInstruction} from '../transaction';
-import assert from '../utils/assert';
-import {PublicKey} from '../publickey';
-
-export type CompiledKeyMeta = {
-  isSigner: boolean;
-  isWritable: boolean;
-  isInvoked: boolean;
-};
-
-type KeyMetaMap = Map<string, CompiledKeyMeta>;
-
-export class CompiledKeys {
-  payer: PublicKey;
-  keyMetaMap: KeyMetaMap;
-
-  constructor(payer: PublicKey, keyMetaMap: KeyMetaMap) {
-    this.payer = payer;
-    this.keyMetaMap = keyMetaMap;
-  }
-
-  static compile(
-    instructions: Array<TransactionInstruction>,
-    payer: PublicKey,
-  ): CompiledKeys {
-    const keyMetaMap: KeyMetaMap = new Map();
-    const getOrInsertDefault = (pubkey: PublicKey): CompiledKeyMeta => {
-      const address = pubkey.toBase58();
-      let keyMeta = keyMetaMap.get(address);
-      if (keyMeta === undefined) {
-        keyMeta = {
-          isSigner: false,
-          isWritable: false,
-          isInvoked: false,
-        };
-        keyMetaMap.set(address, keyMeta);
-      }
-      return keyMeta;
-    };
-
-    const payerKeyMeta = getOrInsertDefault(payer);
-    payerKeyMeta.isSigner = true;
-    payerKeyMeta.isWritable = true;
-
-    for (const ix of instructions) {
-      getOrInsertDefault(ix.programId).isInvoked = true;
-      for (const accountMeta of ix.keys) {
-        const keyMeta = getOrInsertDefault(accountMeta.pubkey);
-        keyMeta.isSigner ||= accountMeta.isSigner;
-        keyMeta.isWritable ||= accountMeta.isWritable;
-      }
-    }
-
-    return new CompiledKeys(payer, keyMetaMap);
-  }
-
-  getMessageComponents(): [MessageHeader, Array<PublicKey>] {
-    const mapEntries = [...this.keyMetaMap.entries()];
-    assert(mapEntries.length <= 256, 'Max static account keys length exceeded');
-
-    const writableSigners = mapEntries.filter(
-      ([, meta]) => meta.isSigner && meta.isWritable,
-    );
-    const readonlySigners = mapEntries.filter(
-      ([, meta]) => meta.isSigner && !meta.isWritable,
-    );
-    const writableNonSigners = mapEntries.filter(
-      ([, meta]) => !meta.isSigner && meta.isWritable,
-    );
-    const readonlyNonSigners = mapEntries.filter(
-      ([, meta]) => !meta.isSigner && !meta.isWritable,
-    );
-
-    const header: MessageHeader = {
-      numRequiredSignatures: writableSigners.length + readonlySigners.length,
-      numReadonlySignedAccounts: readonlySigners.length,
-      numReadonlyUnsignedAccounts: readonlyNonSigners.length,
-    };
-
-    // sanity checks
-    {
-      assert(
-        writableSigners.length > 0,
-        'Expected at least one writable signer key',
-      );
-      const [payerAddress] = writableSigners[0];
-      assert(
-        payerAddress === this.payer.toBase58(),
-        'Expected first writable signer key to be the fee payer',
-      );
-    }
-
-    const staticAccountKeys = [
-      ...writableSigners.map(([address]) => new PublicKey(address)),
-      ...readonlySigners.map(([address]) => new PublicKey(address)),
-      ...writableNonSigners.map(([address]) => new PublicKey(address)),
-      ...readonlyNonSigners.map(([address]) => new PublicKey(address)),
-    ];
-
-    return [header, staticAccountKeys];
-  }
-
-  extractTableLookup(
-    lookupTable: AddressLookupTableAccount,
-  ): [MessageAddressTableLookup, AccountKeysFromLookups] | undefined {
-    const [writableIndexes, drainedWritableKeys] =
-      this.drainKeysFoundInLookupTable(
-        lookupTable.state.addresses,
-        keyMeta =>
-          !keyMeta.isSigner && !keyMeta.isInvoked && keyMeta.isWritable,
-      );
-    const [readonlyIndexes, drainedReadonlyKeys] =
-      this.drainKeysFoundInLookupTable(
-        lookupTable.state.addresses,
-        keyMeta =>
-          !keyMeta.isSigner && !keyMeta.isInvoked && !keyMeta.isWritable,
-      );
-
-    // Don't extract lookup if no keys were found
-    if (writableIndexes.length === 0 && readonlyIndexes.length === 0) {
-      return;
-    }
-
-    return [
-      {
-        accountKey: lookupTable.key,
-        writableIndexes,
-        readonlyIndexes,
-      },
-      {
-        writable: drainedWritableKeys,
-        readonly: drainedReadonlyKeys,
-      },
-    ];
-  }
-
-  /** @internal */
-  private drainKeysFoundInLookupTable(
-    lookupTableEntries: Array<PublicKey>,
-    keyMetaFilter: (keyMeta: CompiledKeyMeta) => boolean,
-  ): [Array<number>, Array<PublicKey>] {
-    const lookupTableIndexes = new Array();
-    const drainedKeys = new Array();
-
-    for (const [address, keyMeta] of this.keyMetaMap.entries()) {
-      if (keyMetaFilter(keyMeta)) {
-        const key = new PublicKey(address);
-        const lookupTableIndex = lookupTableEntries.findIndex(entry =>
-          entry.equals(key),
-        );
-        if (lookupTableIndex >= 0) {
-          assert(lookupTableIndex < 256, 'Max lookup table index exceeded');
-          lookupTableIndexes.push(lookupTableIndex);
-          drainedKeys.push(key);
-          this.keyMetaMap.delete(address);
-        }
-      }
-    }
-
-    return [lookupTableIndexes, drainedKeys];
-  }
-}

package/src/message/index.ts

@@ -1,47 +0,0 @@
-import {PublicKey} from '../publickey';
-
-export * from './account-keys';
-// note: compiled-keys is internal and doesn't need to be exported
-export * from './legacy';
-export * from './versioned';
-export * from './v0';
-
-/**
- * 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 address table lookup used to load additional accounts
- */
-export type MessageAddressTableLookup = {
-  accountKey: PublicKey;
-  writableIndexes: Array<number>;
-  readonlyIndexes: Array<number>;
-};
-
-/**
- * An instruction to execute by a program
- *
- * @property {number} programIdIndex
- * @property {number[]} accountKeyIndexes
- * @property {Uint8Array} data
- */
-export type MessageCompiledInstruction = {
-  /** 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 */
-  accountKeyIndexes: number[];
-  /** The program input data */
-  data: Uint8Array;
-};