FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/@solana/web3.js/src/message/account-keys.ts

@@ -0,0 +1,79 @@
+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,
+      };
+    });
+  }
+}

node_modules/@solana/web3.js/src/message/compiled-keys.ts

@@ -0,0 +1,165 @@
+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];
+  }
+}

node_modules/@solana/web3.js/src/message/index.ts

@@ -0,0 +1,47 @@
+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;
+};

node_modules/@solana/web3.js/src/message/legacy.ts

@@ -0,0 +1,323 @@
+import bs58 from 'bs58';
+import {Buffer} from 'buffer';
+import * as BufferLayout from '@solana/buffer-layout';
+
+import {PublicKey, PUBLIC_KEY_LENGTH} from '../publickey';
+import type {Blockhash} from '../blockhash';
+import * as Layout from '../layout';
+import {PACKET_DATA_SIZE, VERSION_PREFIX_MASK} from '../transaction/constants';
+import * as shortvec from '../utils/shortvec-encoding';
+import {toBuffer} from '../utils/to-buffer';
+import {
+  MessageHeader,
+  MessageAddressTableLookup,
+  MessageCompiledInstruction,
+} from './index';
+import {TransactionInstruction} from '../transaction';
+import {CompiledKeys} from './compiled-keys';
+import {MessageAccountKeys} from './account-keys';
+import {guardedShift, guardedSplice} from '../utils/guarded-array-utils';
+
+/**
+ * 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[] | PublicKey[];
+  /** 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[];
+};
+
+export type CompileLegacyArgs = {
+  payerKey: PublicKey;
+  instructions: Array<TransactionInstruction>;
+  recentBlockhash: Blockhash;
+};
+
+/**
+ * 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],
+      ),
+    );
+  }
+
+  get version(): 'legacy' {
+    return 'legacy';
+  }
+
+  get staticAccountKeys(): Array<PublicKey> {
+    return this.accountKeys;
+  }
+
+  get compiledInstructions(): Array<MessageCompiledInstruction> {
+    return this.instructions.map(
+      (ix): MessageCompiledInstruction => ({
+        programIdIndex: ix.programIdIndex,
+        accountKeyIndexes: ix.accounts,
+        data: bs58.decode(ix.data),
+      }),
+    );
+  }
+
+  get addressTableLookups(): Array<MessageAddressTableLookup> {
+    return [];
+  }
+
+  getAccountKeys(): MessageAccountKeys {
+    return new MessageAccountKeys(this.staticAccountKeys);
+  }
+
+  static compile(args: CompileLegacyArgs): Message {
+    const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);
+    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+    const accountKeys = new MessageAccountKeys(staticAccountKeys);
+    const instructions = accountKeys.compileInstructions(args.instructions).map(
+      (ix: MessageCompiledInstruction): CompiledInstruction => ({
+        programIdIndex: ix.programIdIndex,
+        accounts: ix.accountKeyIndexes,
+        data: bs58.encode(ix.data),
+      }),
+    );
+    return new Message({
+      header,
+      accountKeys: staticAccountKeys,
+      recentBlockhash: args.recentBlockhash,
+      instructions,
+    });
+  }
+
+  isAccountSigner(index: number): boolean {
+    return index < this.header.numRequiredSignatures;
+  }
+
+  isAccountWritable(index: number): boolean {
+    const numSignedAccounts = this.header.numRequiredSignatures;
+    if (index >= this.header.numRequiredSignatures) {
+      const unsignedAccountIndex = index - numSignedAccounts;
+      const numUnsignedAccounts = this.accountKeys.length - numSignedAccounts;
+      const numWritableUnsignedAccounts =
+        numUnsignedAccounts - this.header.numReadonlyUnsignedAccounts;
+      return unsignedAccountIndex < numWritableUnsignedAccounts;
+    } else {
+      const numWritableSignedAccounts =
+        numSignedAccounts - this.header.numReadonlySignedAccounts;
+      return index < numWritableSignedAccounts;
+    }
+  }
+
+  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 = guardedShift(byteArray);
+    if (
+      numRequiredSignatures !==
+      (numRequiredSignatures & VERSION_PREFIX_MASK)
+    ) {
+      throw new Error(
+        'Versioned messages must be deserialized with VersionedMessage.deserialize()',
+      );
+    }
+
+    const numReadonlySignedAccounts = guardedShift(byteArray);
+    const numReadonlyUnsignedAccounts = guardedShift(byteArray);
+
+    const accountCount = shortvec.decodeLength(byteArray);
+    let accountKeys = [];
+    for (let i = 0; i < accountCount; i++) {
+      const account = guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH);
+      accountKeys.push(new PublicKey(Buffer.from(account)));
+    }
+
+    const recentBlockhash = guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH);
+
+    const instructionCount = shortvec.decodeLength(byteArray);
+    let instructions: CompiledInstruction[] = [];
+    for (let i = 0; i < instructionCount; i++) {
+      const programIdIndex = guardedShift(byteArray);
+      const accountCount = shortvec.decodeLength(byteArray);
+      const accounts = guardedSplice(byteArray, 0, accountCount);
+      const dataLength = shortvec.decodeLength(byteArray);
+      const dataSlice = guardedSplice(byteArray, 0, dataLength);
+      const data = bs58.encode(Buffer.from(dataSlice));
+      instructions.push({
+        programIdIndex,
+        accounts,
+        data,
+      });
+    }
+
+    const messageArgs = {
+      header: {
+        numRequiredSignatures,
+        numReadonlySignedAccounts,
+        numReadonlyUnsignedAccounts,
+      },
+      recentBlockhash: bs58.encode(Buffer.from(recentBlockhash)),
+      accountKeys,
+      instructions,
+    };
+
+    return new Message(messageArgs);
+  }
+}

node_modules/@solana/web3.js/src/message/v0.ts

@@ -0,0 +1,513 @@
+import bs58 from 'bs58';
+import * as BufferLayout from '@solana/buffer-layout';
+
+import * as Layout from '../layout';
+import {Blockhash} from '../blockhash';
+import {
+  MessageHeader,
+  MessageAddressTableLookup,
+  MessageCompiledInstruction,
+} from './index';
+import {PublicKey, PUBLIC_KEY_LENGTH} from '../publickey';
+import * as shortvec from '../utils/shortvec-encoding';
+import assert from '../utils/assert';
+import {PACKET_DATA_SIZE, VERSION_PREFIX_MASK} from '../transaction/constants';
+import {TransactionInstruction} from '../transaction';
+import {AddressLookupTableAccount} from '../programs';
+import {CompiledKeys} from './compiled-keys';
+import {AccountKeysFromLookups, MessageAccountKeys} from './account-keys';
+import {guardedShift, guardedSplice} from '../utils/guarded-array-utils';
+
+/**
+ * Message constructor arguments
+ */
+export type MessageV0Args = {
+  /** The message header, identifying signed and read-only `accountKeys` */
+  header: MessageHeader;
+  /** The static account keys used by this transaction */
+  staticAccountKeys: PublicKey[];
+  /** 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. */
+  compiledInstructions: MessageCompiledInstruction[];
+  /** Instructions that will be executed in sequence and committed in one atomic transaction if all succeed. */
+  addressTableLookups: MessageAddressTableLookup[];
+};
+
+export type CompileV0Args = {
+  payerKey: PublicKey;
+  instructions: Array<TransactionInstruction>;
+  recentBlockhash: Blockhash;
+  addressLookupTableAccounts?: Array<AddressLookupTableAccount>;
+};
+
+export type GetAccountKeysArgs =
+  | {
+      accountKeysFromLookups?: AccountKeysFromLookups | null;
+    }
+  | {
+      addressLookupTableAccounts?: AddressLookupTableAccount[] | null;
+    };
+
+export class MessageV0 {
+  header: MessageHeader;
+  staticAccountKeys: Array<PublicKey>;
+  recentBlockhash: Blockhash;
+  compiledInstructions: Array<MessageCompiledInstruction>;
+  addressTableLookups: Array<MessageAddressTableLookup>;
+
+  constructor(args: MessageV0Args) {
+    this.header = args.header;
+    this.staticAccountKeys = args.staticAccountKeys;
+    this.recentBlockhash = args.recentBlockhash;
+    this.compiledInstructions = args.compiledInstructions;
+    this.addressTableLookups = args.addressTableLookups;
+  }
+
+  get version(): 0 {
+    return 0;
+  }
+
+  get numAccountKeysFromLookups(): number {
+    let count = 0;
+    for (const lookup of this.addressTableLookups) {
+      count += lookup.readonlyIndexes.length + lookup.writableIndexes.length;
+    }
+    return count;
+  }
+
+  getAccountKeys(args?: GetAccountKeysArgs): MessageAccountKeys {
+    let accountKeysFromLookups: AccountKeysFromLookups | undefined;
+    if (
+      args &&
+      'accountKeysFromLookups' in args &&
+      args.accountKeysFromLookups
+    ) {
+      if (
+        this.numAccountKeysFromLookups !=
+        args.accountKeysFromLookups.writable.length +
+          args.accountKeysFromLookups.readonly.length
+      ) {
+        throw new Error(
+          'Failed to get account keys because of a mismatch in the number of account keys from lookups',
+        );
+      }
+      accountKeysFromLookups = args.accountKeysFromLookups;
+    } else if (
+      args &&
+      'addressLookupTableAccounts' in args &&
+      args.addressLookupTableAccounts
+    ) {
+      accountKeysFromLookups = this.resolveAddressTableLookups(
+        args.addressLookupTableAccounts,
+      );
+    } else if (this.addressTableLookups.length > 0) {
+      throw new Error(
+        'Failed to get account keys because address table lookups were not resolved',
+      );
+    }
+    return new MessageAccountKeys(
+      this.staticAccountKeys,
+      accountKeysFromLookups,
+    );
+  }
+
+  isAccountSigner(index: number): boolean {
+    return index < this.header.numRequiredSignatures;
+  }
+
+  isAccountWritable(index: number): boolean {
+    const numSignedAccounts = this.header.numRequiredSignatures;
+    const numStaticAccountKeys = this.staticAccountKeys.length;
+    if (index >= numStaticAccountKeys) {
+      const lookupAccountKeysIndex = index - numStaticAccountKeys;
+      const numWritableLookupAccountKeys = this.addressTableLookups.reduce(
+        (count, lookup) => count + lookup.writableIndexes.length,
+        0,
+      );
+      return lookupAccountKeysIndex < numWritableLookupAccountKeys;
+    } else if (index >= this.header.numRequiredSignatures) {
+      const unsignedAccountIndex = index - numSignedAccounts;
+      const numUnsignedAccounts = numStaticAccountKeys - numSignedAccounts;
+      const numWritableUnsignedAccounts =
+        numUnsignedAccounts - this.header.numReadonlyUnsignedAccounts;
+      return unsignedAccountIndex < numWritableUnsignedAccounts;
+    } else {
+      const numWritableSignedAccounts =
+        numSignedAccounts - this.header.numReadonlySignedAccounts;
+      return index < numWritableSignedAccounts;
+    }
+  }
+
+  resolveAddressTableLookups(
+    addressLookupTableAccounts: AddressLookupTableAccount[],
+  ): AccountKeysFromLookups {
+    const accountKeysFromLookups: AccountKeysFromLookups = {
+      writable: [],
+      readonly: [],
+    };
+
+    for (const tableLookup of this.addressTableLookups) {
+      const tableAccount = addressLookupTableAccounts.find(account =>
+        account.key.equals(tableLookup.accountKey),
+      );
+      if (!tableAccount) {
+        throw new Error(
+          `Failed to find address lookup table account for table key ${tableLookup.accountKey.toBase58()}`,
+        );
+      }
+
+      for (const index of tableLookup.writableIndexes) {
+        if (index < tableAccount.state.addresses.length) {
+          accountKeysFromLookups.writable.push(
+            tableAccount.state.addresses[index],
+          );
+        } else {
+          throw new Error(
+            `Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`,
+          );
+        }
+      }
+
+      for (const index of tableLookup.readonlyIndexes) {
+        if (index < tableAccount.state.addresses.length) {
+          accountKeysFromLookups.readonly.push(
+            tableAccount.state.addresses[index],
+          );
+        } else {
+          throw new Error(
+            `Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`,
+          );
+        }
+      }
+    }
+
+    return accountKeysFromLookups;
+  }
+
+  static compile(args: CompileV0Args): MessageV0 {
+    const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);
+
+    const addressTableLookups = new Array<MessageAddressTableLookup>();
+    const accountKeysFromLookups: AccountKeysFromLookups = {
+      writable: new Array(),
+      readonly: new Array(),
+    };
+    const lookupTableAccounts = args.addressLookupTableAccounts || [];
+    for (const lookupTable of lookupTableAccounts) {
+      const extractResult = compiledKeys.extractTableLookup(lookupTable);
+      if (extractResult !== undefined) {
+        const [addressTableLookup, {writable, readonly}] = extractResult;
+        addressTableLookups.push(addressTableLookup);
+        accountKeysFromLookups.writable.push(...writable);
+        accountKeysFromLookups.readonly.push(...readonly);
+      }
+    }
+
+    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+    const accountKeys = new MessageAccountKeys(
+      staticAccountKeys,
+      accountKeysFromLookups,
+    );
+    const compiledInstructions = accountKeys.compileInstructions(
+      args.instructions,
+    );
+    return new MessageV0({
+      header,
+      staticAccountKeys,
+      recentBlockhash: args.recentBlockhash,
+      compiledInstructions,
+      addressTableLookups,
+    });
+  }
+
+  serialize(): Uint8Array {
+    const encodedStaticAccountKeysLength = Array<number>();
+    shortvec.encodeLength(
+      encodedStaticAccountKeysLength,
+      this.staticAccountKeys.length,
+    );
+
+    const serializedInstructions = this.serializeInstructions();
+    const encodedInstructionsLength = Array<number>();
+    shortvec.encodeLength(
+      encodedInstructionsLength,
+      this.compiledInstructions.length,
+    );
+
+    const serializedAddressTableLookups = this.serializeAddressTableLookups();
+    const encodedAddressTableLookupsLength = Array<number>();
+    shortvec.encodeLength(
+      encodedAddressTableLookupsLength,
+      this.addressTableLookups.length,
+    );
+
+    const messageLayout = BufferLayout.struct<{
+      prefix: number;
+      header: MessageHeader;
+      staticAccountKeysLength: Uint8Array;
+      staticAccountKeys: Array<Uint8Array>;
+      recentBlockhash: Uint8Array;
+      instructionsLength: Uint8Array;
+      serializedInstructions: Uint8Array;
+      addressTableLookupsLength: Uint8Array;
+      serializedAddressTableLookups: Uint8Array;
+    }>([
+      BufferLayout.u8('prefix'),
+      BufferLayout.struct<MessageHeader>(
+        [
+          BufferLayout.u8('numRequiredSignatures'),
+          BufferLayout.u8('numReadonlySignedAccounts'),
+          BufferLayout.u8('numReadonlyUnsignedAccounts'),
+        ],
+        'header',
+      ),
+      BufferLayout.blob(
+        encodedStaticAccountKeysLength.length,
+        'staticAccountKeysLength',
+      ),
+      BufferLayout.seq(
+        Layout.publicKey(),
+        this.staticAccountKeys.length,
+        'staticAccountKeys',
+      ),
+      Layout.publicKey('recentBlockhash'),
+      BufferLayout.blob(encodedInstructionsLength.length, 'instructionsLength'),
+      BufferLayout.blob(
+        serializedInstructions.length,
+        'serializedInstructions',
+      ),
+      BufferLayout.blob(
+        encodedAddressTableLookupsLength.length,
+        'addressTableLookupsLength',
+      ),
+      BufferLayout.blob(
+        serializedAddressTableLookups.length,
+        'serializedAddressTableLookups',
+      ),
+    ]);
+
+    const serializedMessage = new Uint8Array(PACKET_DATA_SIZE);
+    const MESSAGE_VERSION_0_PREFIX = 1 << 7;
+    const serializedMessageLength = messageLayout.encode(
+      {
+        prefix: MESSAGE_VERSION_0_PREFIX,
+        header: this.header,
+        staticAccountKeysLength: new Uint8Array(encodedStaticAccountKeysLength),
+        staticAccountKeys: this.staticAccountKeys.map(key => key.toBytes()),
+        recentBlockhash: bs58.decode(this.recentBlockhash),
+        instructionsLength: new Uint8Array(encodedInstructionsLength),
+        serializedInstructions,
+        addressTableLookupsLength: new Uint8Array(
+          encodedAddressTableLookupsLength,
+        ),
+        serializedAddressTableLookups,
+      },
+      serializedMessage,
+    );
+    return serializedMessage.slice(0, serializedMessageLength);
+  }
+
+  private serializeInstructions(): Uint8Array {
+    let serializedLength = 0;
+    const serializedInstructions = new Uint8Array(PACKET_DATA_SIZE);
+    for (const instruction of this.compiledInstructions) {
+      const encodedAccountKeyIndexesLength = Array<number>();
+      shortvec.encodeLength(
+        encodedAccountKeyIndexesLength,
+        instruction.accountKeyIndexes.length,
+      );
+
+      const encodedDataLength = Array<number>();
+      shortvec.encodeLength(encodedDataLength, instruction.data.length);
+
+      const instructionLayout = BufferLayout.struct<{
+        programIdIndex: number;
+        encodedAccountKeyIndexesLength: Uint8Array;
+        accountKeyIndexes: number[];
+        encodedDataLength: Uint8Array;
+        data: Uint8Array;
+      }>([
+        BufferLayout.u8('programIdIndex'),
+        BufferLayout.blob(
+          encodedAccountKeyIndexesLength.length,
+          'encodedAccountKeyIndexesLength',
+        ),
+        BufferLayout.seq(
+          BufferLayout.u8(),
+          instruction.accountKeyIndexes.length,
+          'accountKeyIndexes',
+        ),
+        BufferLayout.blob(encodedDataLength.length, 'encodedDataLength'),
+        BufferLayout.blob(instruction.data.length, 'data'),
+      ]);
+
+      serializedLength += instructionLayout.encode(
+        {
+          programIdIndex: instruction.programIdIndex,
+          encodedAccountKeyIndexesLength: new Uint8Array(
+            encodedAccountKeyIndexesLength,
+          ),
+          accountKeyIndexes: instruction.accountKeyIndexes,
+          encodedDataLength: new Uint8Array(encodedDataLength),
+          data: instruction.data,
+        },
+        serializedInstructions,
+        serializedLength,
+      );
+    }
+
+    return serializedInstructions.slice(0, serializedLength);
+  }
+
+  private serializeAddressTableLookups(): Uint8Array {
+    let serializedLength = 0;
+    const serializedAddressTableLookups = new Uint8Array(PACKET_DATA_SIZE);
+    for (const lookup of this.addressTableLookups) {
+      const encodedWritableIndexesLength = Array<number>();
+      shortvec.encodeLength(
+        encodedWritableIndexesLength,
+        lookup.writableIndexes.length,
+      );
+
+      const encodedReadonlyIndexesLength = Array<number>();
+      shortvec.encodeLength(
+        encodedReadonlyIndexesLength,
+        lookup.readonlyIndexes.length,
+      );
+
+      const addressTableLookupLayout = BufferLayout.struct<{
+        accountKey: Uint8Array;
+        encodedWritableIndexesLength: Uint8Array;
+        writableIndexes: number[];
+        encodedReadonlyIndexesLength: Uint8Array;
+        readonlyIndexes: number[];
+      }>([
+        Layout.publicKey('accountKey'),
+        BufferLayout.blob(
+          encodedWritableIndexesLength.length,
+          'encodedWritableIndexesLength',
+        ),
+        BufferLayout.seq(
+          BufferLayout.u8(),
+          lookup.writableIndexes.length,
+          'writableIndexes',
+        ),
+        BufferLayout.blob(
+          encodedReadonlyIndexesLength.length,
+          'encodedReadonlyIndexesLength',
+        ),
+        BufferLayout.seq(
+          BufferLayout.u8(),
+          lookup.readonlyIndexes.length,
+          'readonlyIndexes',
+        ),
+      ]);
+
+      serializedLength += addressTableLookupLayout.encode(
+        {
+          accountKey: lookup.accountKey.toBytes(),
+          encodedWritableIndexesLength: new Uint8Array(
+            encodedWritableIndexesLength,
+          ),
+          writableIndexes: lookup.writableIndexes,
+          encodedReadonlyIndexesLength: new Uint8Array(
+            encodedReadonlyIndexesLength,
+          ),
+          readonlyIndexes: lookup.readonlyIndexes,
+        },
+        serializedAddressTableLookups,
+        serializedLength,
+      );
+    }
+
+    return serializedAddressTableLookups.slice(0, serializedLength);
+  }
+
+  static deserialize(serializedMessage: Uint8Array): MessageV0 {
+    let byteArray = [...serializedMessage];
+
+    const prefix = guardedShift(byteArray);
+    const maskedPrefix = prefix & VERSION_PREFIX_MASK;
+    assert(
+      prefix !== maskedPrefix,
+      `Expected versioned message but received legacy message`,
+    );
+
+    const version = maskedPrefix;
+    assert(
+      version === 0,
+      `Expected versioned message with version 0 but found version ${version}`,
+    );
+
+    const header: MessageHeader = {
+      numRequiredSignatures: guardedShift(byteArray),
+      numReadonlySignedAccounts: guardedShift(byteArray),
+      numReadonlyUnsignedAccounts: guardedShift(byteArray),
+    };
+
+    const staticAccountKeys = [];
+    const staticAccountKeysLength = shortvec.decodeLength(byteArray);
+    for (let i = 0; i < staticAccountKeysLength; i++) {
+      staticAccountKeys.push(
+        new PublicKey(guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH)),
+      );
+    }
+
+    const recentBlockhash = bs58.encode(
+      guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH),
+    );
+
+    const instructionCount = shortvec.decodeLength(byteArray);
+    const compiledInstructions: MessageCompiledInstruction[] = [];
+    for (let i = 0; i < instructionCount; i++) {
+      const programIdIndex = guardedShift(byteArray);
+      const accountKeyIndexesLength = shortvec.decodeLength(byteArray);
+      const accountKeyIndexes = guardedSplice(
+        byteArray,
+        0,
+        accountKeyIndexesLength,
+      );
+      const dataLength = shortvec.decodeLength(byteArray);
+      const data = new Uint8Array(guardedSplice(byteArray, 0, dataLength));
+      compiledInstructions.push({
+        programIdIndex,
+        accountKeyIndexes,
+        data,
+      });
+    }
+
+    const addressTableLookupsCount = shortvec.decodeLength(byteArray);
+    const addressTableLookups: MessageAddressTableLookup[] = [];
+    for (let i = 0; i < addressTableLookupsCount; i++) {
+      const accountKey = new PublicKey(
+        guardedSplice(byteArray, 0, PUBLIC_KEY_LENGTH),
+      );
+      const writableIndexesLength = shortvec.decodeLength(byteArray);
+      const writableIndexes = guardedSplice(
+        byteArray,
+        0,
+        writableIndexesLength,
+      );
+      const readonlyIndexesLength = shortvec.decodeLength(byteArray);
+      const readonlyIndexes = guardedSplice(
+        byteArray,
+        0,
+        readonlyIndexesLength,
+      );
+      addressTableLookups.push({
+        accountKey,
+        writableIndexes,
+        readonlyIndexes,
+      });
+    }
+
+    return new MessageV0({
+      header,
+      staticAccountKeys,
+      recentBlockhash,
+      compiledInstructions,
+      addressTableLookups,
+    });
+  }
+}

node_modules/@solana/web3.js/src/message/versioned.ts

@@ -0,0 +1,36 @@
+import {VERSION_PREFIX_MASK} from '../transaction/constants';
+import {Message} from './legacy';
+import {MessageV0} from './v0';
+
+export type VersionedMessage = Message | MessageV0;
+// eslint-disable-next-line no-redeclare
+export const VersionedMessage = {
+  deserializeMessageVersion(serializedMessage: Uint8Array): 'legacy' | number {
+    const prefix = serializedMessage[0];
+    const maskedPrefix = prefix & VERSION_PREFIX_MASK;
+
+    // if the highest bit of the prefix is not set, the message is not versioned
+    if (maskedPrefix === prefix) {
+      return 'legacy';
+    }
+
+    // the lower 7 bits of the prefix indicate the message version
+    return maskedPrefix;
+  },
+
+  deserialize: (serializedMessage: Uint8Array): VersionedMessage => {
+    const version =
+      VersionedMessage.deserializeMessageVersion(serializedMessage);
+    if (version === 'legacy') {
+      return Message.from(serializedMessage);
+    }
+
+    if (version === 0) {
+      return MessageV0.deserialize(serializedMessage);
+    } else {
+      throw new Error(
+        `Transaction message version ${version} deserialization is not supported`,
+      );
+    }
+  },
+};