@solana/web3.js 1.78.3 → 2.0.0-experimental.0108bc7

package/src/transaction/legacy.ts

@@ -1,948 +0,0 @@
-import bs58 from 'bs58';
-import {Buffer} from 'buffer';
-
-import {PACKET_DATA_SIZE, SIGNATURE_LENGTH_IN_BYTES} from './constants';
-import {Connection} from '../connection';
-import {Message} from '../message';
-import {PublicKey} from '../publickey';
-import * as shortvec from '../utils/shortvec-encoding';
-import {toBuffer} from '../utils/to-buffer';
-import invariant from '../utils/assert';
-import type {Signer} from '../keypair';
-import type {Blockhash} from '../blockhash';
-import type {CompiledInstruction} from '../message';
-import {sign, verify} from '../utils/ed25519';
-
-/**
- * Transaction signature as base-58 encoded string
- */
-export type TransactionSignature = string;
-
-export const enum TransactionStatus {
-  BLOCKHEIGHT_EXCEEDED,
-  PROCESSED,
-  TIMED_OUT,
-  NONCE_INVALID,
-}
-
-/**
- * Default (empty) signature
- */
-const DEFAULT_SIGNATURE = Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
-
-/**
- * Account metadata used to define instructions
- */
-export type AccountMeta = {
-  /** An account's public key */
-  pubkey: PublicKey;
-  /** True if an instruction requires a transaction signature matching `pubkey` */
-  isSigner: boolean;
-  /** True if the `pubkey` can be loaded as a read-write account. */
-  isWritable: boolean;
-};
-
-/**
- * List of TransactionInstruction object fields that may be initialized at construction
- */
-export type TransactionInstructionCtorFields = {
-  keys: Array<AccountMeta>;
-  programId: PublicKey;
-  data?: Buffer;
-};
-
-/**
- * Configuration object for Transaction.serialize()
- */
-export type SerializeConfig = {
-  /** Require all transaction signatures be present (default: true) */
-  requireAllSignatures?: boolean;
-  /** Verify provided signatures (default: true) */
-  verifySignatures?: boolean;
-};
-
-/**
- * @internal
- */
-export interface TransactionInstructionJSON {
-  keys: {
-    pubkey: string;
-    isSigner: boolean;
-    isWritable: boolean;
-  }[];
-  programId: string;
-  data: number[];
-}
-
-/**
- * Transaction Instruction class
- */
-export class TransactionInstruction {
-  /**
-   * Public keys to include in this transaction
-   * Boolean represents whether this pubkey needs to sign the transaction
-   */
-  keys: Array<AccountMeta>;
-
-  /**
-   * Program Id to execute
-   */
-  programId: PublicKey;
-
-  /**
-   * Program input
-   */
-  data: Buffer = Buffer.alloc(0);
-
-  constructor(opts: TransactionInstructionCtorFields) {
-    this.programId = opts.programId;
-    this.keys = opts.keys;
-    if (opts.data) {
-      this.data = opts.data;
-    }
-  }
-
-  /**
-   * @internal
-   */
-  toJSON(): TransactionInstructionJSON {
-    return {
-      keys: this.keys.map(({pubkey, isSigner, isWritable}) => ({
-        pubkey: pubkey.toJSON(),
-        isSigner,
-        isWritable,
-      })),
-      programId: this.programId.toJSON(),
-      data: [...this.data],
-    };
-  }
-}
-
-/**
- * Pair of signature and corresponding public key
- */
-export type SignaturePubkeyPair = {
-  signature: Buffer | null;
-  publicKey: PublicKey;
-};
-
-/**
- * List of Transaction object fields that may be initialized at construction
- */
-export type TransactionCtorFields_DEPRECATED = {
-  /** Optional nonce information used for offline nonce'd transactions */
-  nonceInfo?: NonceInformation | null;
-  /** The transaction fee payer */
-  feePayer?: PublicKey | null;
-  /** One or more signatures */
-  signatures?: Array<SignaturePubkeyPair>;
-  /** A recent blockhash */
-  recentBlockhash?: Blockhash;
-};
-
-// For backward compatibility; an unfortunate consequence of being
-// forced to over-export types by the documentation generator.
-// See https://github.com/solana-labs/solana/pull/25820
-export type TransactionCtorFields = TransactionCtorFields_DEPRECATED;
-
-/**
- * Blockhash-based transactions have a lifetime that are defined by
- * the blockhash they include. Any transaction whose blockhash is
- * too old will be rejected.
- */
-export type TransactionBlockhashCtor = {
-  /** The transaction fee payer */
-  feePayer?: PublicKey | null;
-  /** One or more signatures */
-  signatures?: Array<SignaturePubkeyPair>;
-  /** A recent blockhash */
-  blockhash: Blockhash;
-  /** the last block chain can advance to before tx is declared expired */
-  lastValidBlockHeight: number;
-};
-
-/**
- * Use these options to construct a durable nonce transaction.
- */
-export type TransactionNonceCtor = {
-  /** The transaction fee payer */
-  feePayer?: PublicKey | null;
-  minContextSlot: number;
-  nonceInfo: NonceInformation;
-  /** One or more signatures */
-  signatures?: Array<SignaturePubkeyPair>;
-};
-
-/**
- * Nonce information to be used to build an offline Transaction.
- */
-export type NonceInformation = {
-  /** The current blockhash stored in the nonce */
-  nonce: Blockhash;
-  /** AdvanceNonceAccount Instruction */
-  nonceInstruction: TransactionInstruction;
-};
-
-/**
- * @internal
- */
-export interface TransactionJSON {
-  recentBlockhash: string | null;
-  feePayer: string | null;
-  nonceInfo: {
-    nonce: string;
-    nonceInstruction: TransactionInstructionJSON;
-  } | null;
-  instructions: TransactionInstructionJSON[];
-  signers: string[];
-}
-
-/**
- * Transaction class
- */
-export class Transaction {
-  /**
-   * Signatures for the transaction.  Typically created by invoking the
-   * `sign()` method
-   */
-  signatures: Array<SignaturePubkeyPair> = [];
-
-  /**
-   * The first (payer) Transaction signature
-   *
-   * @returns {Buffer | null} Buffer of payer's signature
-   */
-  get signature(): Buffer | null {
-    if (this.signatures.length > 0) {
-      return this.signatures[0].signature;
-    }
-    return null;
-  }
-
-  /**
-   * The transaction fee payer
-   */
-  feePayer?: PublicKey;
-
-  /**
-   * The instructions to atomically execute
-   */
-  instructions: Array<TransactionInstruction> = [];
-
-  /**
-   * A recent transaction id. Must be populated by the caller
-   */
-  recentBlockhash?: Blockhash;
-
-  /**
-   * the last block chain can advance to before tx is declared expired
-   * */
-  lastValidBlockHeight?: number;
-
-  /**
-   * Optional Nonce information. If populated, transaction will use a durable
-   * Nonce hash instead of a recentBlockhash. Must be populated by the caller
-   */
-  nonceInfo?: NonceInformation;
-
-  /**
-   * If this is a nonce transaction this represents the minimum slot from which
-   * to evaluate if the nonce has advanced when attempting to confirm the
-   * transaction. This protects against a case where the transaction confirmation
-   * logic loads the nonce account from an old slot and assumes the mismatch in
-   * nonce value implies that the nonce has been advanced.
-   */
-  minNonceContextSlot?: number;
-
-  /**
-   * @internal
-   */
-  _message?: Message;
-
-  /**
-   * @internal
-   */
-  _json?: TransactionJSON;
-
-  // Construct a transaction with a blockhash and lastValidBlockHeight
-  constructor(opts?: TransactionBlockhashCtor);
-
-  // Construct a transaction using a durable nonce
-  constructor(opts?: TransactionNonceCtor);
-
-  /**
-   * @deprecated `TransactionCtorFields` has been deprecated and will be removed in a future version.
-   * Please supply a `TransactionBlockhashCtor` instead.
-   */
-  constructor(opts?: TransactionCtorFields_DEPRECATED);
-
-  /**
-   * Construct an empty Transaction
-   */
-  constructor(
-    opts?:
-      | TransactionBlockhashCtor
-      | TransactionNonceCtor
-      | TransactionCtorFields_DEPRECATED,
-  ) {
-    if (!opts) {
-      return;
-    }
-    if (opts.feePayer) {
-      this.feePayer = opts.feePayer;
-    }
-    if (opts.signatures) {
-      this.signatures = opts.signatures;
-    }
-    if (Object.prototype.hasOwnProperty.call(opts, 'nonceInfo')) {
-      const {minContextSlot, nonceInfo} = opts as TransactionNonceCtor;
-      this.minNonceContextSlot = minContextSlot;
-      this.nonceInfo = nonceInfo;
-    } else if (
-      Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')
-    ) {
-      const {blockhash, lastValidBlockHeight} =
-        opts as TransactionBlockhashCtor;
-      this.recentBlockhash = blockhash;
-      this.lastValidBlockHeight = lastValidBlockHeight;
-    } else {
-      const {recentBlockhash, nonceInfo} =
-        opts as TransactionCtorFields_DEPRECATED;
-      if (nonceInfo) {
-        this.nonceInfo = nonceInfo;
-      }
-      this.recentBlockhash = recentBlockhash;
-    }
-  }
-
-  /**
-   * @internal
-   */
-  toJSON(): TransactionJSON {
-    return {
-      recentBlockhash: this.recentBlockhash || null,
-      feePayer: this.feePayer ? this.feePayer.toJSON() : null,
-      nonceInfo: this.nonceInfo
-        ? {
-            nonce: this.nonceInfo.nonce,
-            nonceInstruction: this.nonceInfo.nonceInstruction.toJSON(),
-          }
-        : null,
-      instructions: this.instructions.map(instruction => instruction.toJSON()),
-      signers: this.signatures.map(({publicKey}) => {
-        return publicKey.toJSON();
-      }),
-    };
-  }
-
-  /**
-   * Add one or more instructions to this Transaction
-   *
-   * @param {Array< Transaction | TransactionInstruction | TransactionInstructionCtorFields >} items - Instructions to add to the Transaction
-   */
-  add(
-    ...items: Array<
-      Transaction | TransactionInstruction | TransactionInstructionCtorFields
-    >
-  ): Transaction {
-    if (items.length === 0) {
-      throw new Error('No instructions');
-    }
-
-    items.forEach((item: any) => {
-      if ('instructions' in item) {
-        this.instructions = this.instructions.concat(item.instructions);
-      } else if ('data' in item && 'programId' in item && 'keys' in item) {
-        this.instructions.push(item);
-      } else {
-        this.instructions.push(new TransactionInstruction(item));
-      }
-    });
-    return this;
-  }
-
-  /**
-   * Compile transaction data
-   */
-  compileMessage(): Message {
-    if (
-      this._message &&
-      JSON.stringify(this.toJSON()) === JSON.stringify(this._json)
-    ) {
-      return this._message;
-    }
-
-    let recentBlockhash;
-    let instructions: TransactionInstruction[];
-    if (this.nonceInfo) {
-      recentBlockhash = this.nonceInfo.nonce;
-      if (this.instructions[0] != this.nonceInfo.nonceInstruction) {
-        instructions = [this.nonceInfo.nonceInstruction, ...this.instructions];
-      } else {
-        instructions = this.instructions;
-      }
-    } else {
-      recentBlockhash = this.recentBlockhash;
-      instructions = this.instructions;
-    }
-    if (!recentBlockhash) {
-      throw new Error('Transaction recentBlockhash required');
-    }
-
-    if (instructions.length < 1) {
-      console.warn('No instructions provided');
-    }
-
-    let feePayer: PublicKey;
-    if (this.feePayer) {
-      feePayer = this.feePayer;
-    } else if (this.signatures.length > 0 && this.signatures[0].publicKey) {
-      // Use implicit fee payer
-      feePayer = this.signatures[0].publicKey;
-    } else {
-      throw new Error('Transaction fee payer required');
-    }
-
-    for (let i = 0; i < instructions.length; i++) {
-      if (instructions[i].programId === undefined) {
-        throw new Error(
-          `Transaction instruction index ${i} has undefined program id`,
-        );
-      }
-    }
-
-    const programIds: string[] = [];
-    const accountMetas: AccountMeta[] = [];
-    instructions.forEach(instruction => {
-      instruction.keys.forEach(accountMeta => {
-        accountMetas.push({...accountMeta});
-      });
-
-      const programId = instruction.programId.toString();
-      if (!programIds.includes(programId)) {
-        programIds.push(programId);
-      }
-    });
-
-    // Append programID account metas
-    programIds.forEach(programId => {
-      accountMetas.push({
-        pubkey: new PublicKey(programId),
-        isSigner: false,
-        isWritable: false,
-      });
-    });
-
-    // Cull duplicate account metas
-    const uniqueMetas: AccountMeta[] = [];
-    accountMetas.forEach(accountMeta => {
-      const pubkeyString = accountMeta.pubkey.toString();
-      const uniqueIndex = uniqueMetas.findIndex(x => {
-        return x.pubkey.toString() === pubkeyString;
-      });
-      if (uniqueIndex > -1) {
-        uniqueMetas[uniqueIndex].isWritable =
-          uniqueMetas[uniqueIndex].isWritable || accountMeta.isWritable;
-        uniqueMetas[uniqueIndex].isSigner =
-          uniqueMetas[uniqueIndex].isSigner || accountMeta.isSigner;
-      } else {
-        uniqueMetas.push(accountMeta);
-      }
-    });
-
-    // Sort. Prioritizing first by signer, then by writable
-    uniqueMetas.sort(function (x, y) {
-      if (x.isSigner !== y.isSigner) {
-        // Signers always come before non-signers
-        return x.isSigner ? -1 : 1;
-      }
-      if (x.isWritable !== y.isWritable) {
-        // Writable accounts always come before read-only accounts
-        return x.isWritable ? -1 : 1;
-      }
-      // Otherwise, sort by pubkey, stringwise.
-      const options = {
-        localeMatcher: 'best fit',
-        usage: 'sort',
-        sensitivity: 'variant',
-        ignorePunctuation: false,
-        numeric: false,
-        caseFirst: 'lower',
-      } as Intl.CollatorOptions;
-      return x.pubkey
-        .toBase58()
-        .localeCompare(y.pubkey.toBase58(), 'en', options);
-    });
-
-    // Move fee payer to the front
-    const feePayerIndex = uniqueMetas.findIndex(x => {
-      return x.pubkey.equals(feePayer);
-    });
-    if (feePayerIndex > -1) {
-      const [payerMeta] = uniqueMetas.splice(feePayerIndex, 1);
-      payerMeta.isSigner = true;
-      payerMeta.isWritable = true;
-      uniqueMetas.unshift(payerMeta);
-    } else {
-      uniqueMetas.unshift({
-        pubkey: feePayer,
-        isSigner: true,
-        isWritable: true,
-      });
-    }
-
-    // Disallow unknown signers
-    for (const signature of this.signatures) {
-      const uniqueIndex = uniqueMetas.findIndex(x => {
-        return x.pubkey.equals(signature.publicKey);
-      });
-      if (uniqueIndex > -1) {
-        if (!uniqueMetas[uniqueIndex].isSigner) {
-          uniqueMetas[uniqueIndex].isSigner = true;
-          console.warn(
-            'Transaction references a signature that is unnecessary, ' +
-              'only the fee payer and instruction signer accounts should sign a transaction. ' +
-              'This behavior is deprecated and will throw an error in the next major version release.',
-          );
-        }
-      } else {
-        throw new Error(`unknown signer: ${signature.publicKey.toString()}`);
-      }
-    }
-
-    let numRequiredSignatures = 0;
-    let numReadonlySignedAccounts = 0;
-    let numReadonlyUnsignedAccounts = 0;
-
-    // Split out signing from non-signing keys and count header values
-    const signedKeys: string[] = [];
-    const unsignedKeys: string[] = [];
-    uniqueMetas.forEach(({pubkey, isSigner, isWritable}) => {
-      if (isSigner) {
-        signedKeys.push(pubkey.toString());
-        numRequiredSignatures += 1;
-        if (!isWritable) {
-          numReadonlySignedAccounts += 1;
-        }
-      } else {
-        unsignedKeys.push(pubkey.toString());
-        if (!isWritable) {
-          numReadonlyUnsignedAccounts += 1;
-        }
-      }
-    });
-
-    const accountKeys = signedKeys.concat(unsignedKeys);
-    const compiledInstructions: CompiledInstruction[] = instructions.map(
-      instruction => {
-        const {data, programId} = instruction;
-        return {
-          programIdIndex: accountKeys.indexOf(programId.toString()),
-          accounts: instruction.keys.map(meta =>
-            accountKeys.indexOf(meta.pubkey.toString()),
-          ),
-          data: bs58.encode(data),
-        };
-      },
-    );
-
-    compiledInstructions.forEach(instruction => {
-      invariant(instruction.programIdIndex >= 0);
-      instruction.accounts.forEach(keyIndex => invariant(keyIndex >= 0));
-    });
-
-    return new Message({
-      header: {
-        numRequiredSignatures,
-        numReadonlySignedAccounts,
-        numReadonlyUnsignedAccounts,
-      },
-      accountKeys,
-      recentBlockhash,
-      instructions: compiledInstructions,
-    });
-  }
-
-  /**
-   * @internal
-   */
-  _compile(): Message {
-    const message = this.compileMessage();
-    const signedKeys = message.accountKeys.slice(
-      0,
-      message.header.numRequiredSignatures,
-    );
-
-    if (this.signatures.length === signedKeys.length) {
-      const valid = this.signatures.every((pair, index) => {
-        return signedKeys[index].equals(pair.publicKey);
-      });
-
-      if (valid) return message;
-    }
-
-    this.signatures = signedKeys.map(publicKey => ({
-      signature: null,
-      publicKey,
-    }));
-
-    return message;
-  }
-
-  /**
-   * Get a buffer of the Transaction data that need to be covered by signatures
-   */
-  serializeMessage(): Buffer {
-    return this._compile().serialize();
-  }
-
-  /**
-   * Get the estimated fee associated with a transaction
-   *
-   * @param {Connection} connection Connection to RPC Endpoint.
-   *
-   * @returns {Promise<number | null>} The estimated fee for the transaction
-   */
-  async getEstimatedFee(connection: Connection): Promise<number | null> {
-    return (await connection.getFeeForMessage(this.compileMessage())).value;
-  }
-
-  /**
-   * Specify the public keys which will be used to sign the Transaction.
-   * The first signer will be used as the transaction fee payer account.
-   *
-   * Signatures can be added with either `partialSign` or `addSignature`
-   *
-   * @deprecated Deprecated since v0.84.0. Only the fee payer needs to be
-   * specified and it can be set in the Transaction constructor or with the
-   * `feePayer` property.
-   */
-  setSigners(...signers: Array<PublicKey>) {
-    if (signers.length === 0) {
-      throw new Error('No signers');
-    }
-
-    const seen = new Set();
-    this.signatures = signers
-      .filter(publicKey => {
-        const key = publicKey.toString();
-        if (seen.has(key)) {
-          return false;
-        } else {
-          seen.add(key);
-          return true;
-        }
-      })
-      .map(publicKey => ({signature: null, publicKey}));
-  }
-
-  /**
-   * Sign the Transaction with the specified signers. Multiple signatures may
-   * be applied to a Transaction. The first signature is considered "primary"
-   * and is used identify and confirm transactions.
-   *
-   * If the Transaction `feePayer` is not set, the first signer will be used
-   * as the transaction fee payer account.
-   *
-   * Transaction fields should not be modified after the first call to `sign`,
-   * as doing so may invalidate the signature and cause the Transaction to be
-   * rejected.
-   *
-   * The Transaction must be assigned a valid `recentBlockhash` before invoking this method
-   *
-   * @param {Array<Signer>} signers Array of signers that will sign the transaction
-   */
-  sign(...signers: Array<Signer>) {
-    if (signers.length === 0) {
-      throw new Error('No signers');
-    }
-
-    // Dedupe signers
-    const seen = new Set();
-    const uniqueSigners = [];
-    for (const signer of signers) {
-      const key = signer.publicKey.toString();
-      if (seen.has(key)) {
-        continue;
-      } else {
-        seen.add(key);
-        uniqueSigners.push(signer);
-      }
-    }
-
-    this.signatures = uniqueSigners.map(signer => ({
-      signature: null,
-      publicKey: signer.publicKey,
-    }));
-
-    const message = this._compile();
-    this._partialSign(message, ...uniqueSigners);
-  }
-
-  /**
-   * Partially sign a transaction with the specified accounts. All accounts must
-   * correspond to either the fee payer or a signer account in the transaction
-   * instructions.
-   *
-   * All the caveats from the `sign` method apply to `partialSign`
-   *
-   * @param {Array<Signer>} signers Array of signers that will sign the transaction
-   */
-  partialSign(...signers: Array<Signer>) {
-    if (signers.length === 0) {
-      throw new Error('No signers');
-    }
-
-    // Dedupe signers
-    const seen = new Set();
-    const uniqueSigners = [];
-    for (const signer of signers) {
-      const key = signer.publicKey.toString();
-      if (seen.has(key)) {
-        continue;
-      } else {
-        seen.add(key);
-        uniqueSigners.push(signer);
-      }
-    }
-
-    const message = this._compile();
-    this._partialSign(message, ...uniqueSigners);
-  }
-
-  /**
-   * @internal
-   */
-  _partialSign(message: Message, ...signers: Array<Signer>) {
-    const signData = message.serialize();
-    signers.forEach(signer => {
-      const signature = sign(signData, signer.secretKey);
-      this._addSignature(signer.publicKey, toBuffer(signature));
-    });
-  }
-
-  /**
-   * Add an externally created signature to a transaction. The public key
-   * must correspond to either the fee payer or a signer account in the transaction
-   * instructions.
-   *
-   * @param {PublicKey} pubkey Public key that will be added to the transaction.
-   * @param {Buffer} signature An externally created signature to add to the transaction.
-   */
-  addSignature(pubkey: PublicKey, signature: Buffer) {
-    this._compile(); // Ensure signatures array is populated
-    this._addSignature(pubkey, signature);
-  }
-
-  /**
-   * @internal
-   */
-  _addSignature(pubkey: PublicKey, signature: Buffer) {
-    invariant(signature.length === 64);
-
-    const index = this.signatures.findIndex(sigpair =>
-      pubkey.equals(sigpair.publicKey),
-    );
-    if (index < 0) {
-      throw new Error(`unknown signer: ${pubkey.toString()}`);
-    }
-
-    this.signatures[index].signature = Buffer.from(signature);
-  }
-
-  /**
-   * Verify signatures of a Transaction
-   * Optional parameter specifies if we're expecting a fully signed Transaction or a partially signed one.
-   * If no boolean is provided, we expect a fully signed Transaction by default.
-   *
-   * @param {boolean} [requireAllSignatures=true] Require a fully signed Transaction
-   */
-  verifySignatures(requireAllSignatures?: boolean): boolean {
-    return this._verifySignatures(
-      this.serializeMessage(),
-      requireAllSignatures === undefined ? true : requireAllSignatures,
-    );
-  }
-
-  /**
-   * @internal
-   */
-  _verifySignatures(
-    signData: Uint8Array,
-    requireAllSignatures: boolean,
-  ): boolean {
-    for (const {signature, publicKey} of this.signatures) {
-      if (signature === null) {
-        if (requireAllSignatures) {
-          return false;
-        }
-      } else {
-        if (!verify(signature, signData, publicKey.toBytes())) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Serialize the Transaction in the wire format.
-   *
-   * @param {Buffer} [config] Config of transaction.
-   *
-   * @returns {Buffer} Signature of transaction in wire format.
-   */
-  serialize(config?: SerializeConfig): Buffer {
-    const {requireAllSignatures, verifySignatures} = Object.assign(
-      {requireAllSignatures: true, verifySignatures: true},
-      config,
-    );
-
-    const signData = this.serializeMessage();
-    if (
-      verifySignatures &&
-      !this._verifySignatures(signData, requireAllSignatures)
-    ) {
-      throw new Error('Signature verification failed');
-    }
-
-    return this._serialize(signData);
-  }
-
-  /**
-   * @internal
-   */
-  _serialize(signData: Buffer): Buffer {
-    const {signatures} = this;
-    const signatureCount: number[] = [];
-    shortvec.encodeLength(signatureCount, signatures.length);
-    const transactionLength =
-      signatureCount.length + signatures.length * 64 + signData.length;
-    const wireTransaction = Buffer.alloc(transactionLength);
-    invariant(signatures.length < 256);
-    Buffer.from(signatureCount).copy(wireTransaction, 0);
-    signatures.forEach(({signature}, index) => {
-      if (signature !== null) {
-        invariant(signature.length === 64, `signature has invalid length`);
-        Buffer.from(signature).copy(
-          wireTransaction,
-          signatureCount.length + index * 64,
-        );
-      }
-    });
-    signData.copy(
-      wireTransaction,
-      signatureCount.length + signatures.length * 64,
-    );
-    invariant(
-      wireTransaction.length <= PACKET_DATA_SIZE,
-      `Transaction too large: ${wireTransaction.length} > ${PACKET_DATA_SIZE}`,
-    );
-    return wireTransaction;
-  }
-
-  /**
-   * Deprecated method
-   * @internal
-   */
-  get keys(): Array<PublicKey> {
-    invariant(this.instructions.length === 1);
-    return this.instructions[0].keys.map(keyObj => keyObj.pubkey);
-  }
-
-  /**
-   * Deprecated method
-   * @internal
-   */
-  get programId(): PublicKey {
-    invariant(this.instructions.length === 1);
-    return this.instructions[0].programId;
-  }
-
-  /**
-   * Deprecated method
-   * @internal
-   */
-  get data(): Buffer {
-    invariant(this.instructions.length === 1);
-    return this.instructions[0].data;
-  }
-
-  /**
-   * Parse a wire transaction into a Transaction object.
-   *
-   * @param {Buffer | Uint8Array | Array<number>} buffer Signature of wire Transaction
-   *
-   * @returns {Transaction} Transaction associated with the signature
-   */
-  static from(buffer: Buffer | Uint8Array | Array<number>): Transaction {
-    // Slice up wire data
-    let byteArray = [...buffer];
-
-    const signatureCount = shortvec.decodeLength(byteArray);
-    let signatures = [];
-    for (let i = 0; i < signatureCount; i++) {
-      const signature = byteArray.slice(0, SIGNATURE_LENGTH_IN_BYTES);
-      byteArray = byteArray.slice(SIGNATURE_LENGTH_IN_BYTES);
-      signatures.push(bs58.encode(Buffer.from(signature)));
-    }
-
-    return Transaction.populate(Message.from(byteArray), signatures);
-  }
-
-  /**
-   * Populate Transaction object from message and signatures
-   *
-   * @param {Message} message Message of transaction
-   * @param {Array<string>} signatures List of signatures to assign to the transaction
-   *
-   * @returns {Transaction} The populated Transaction
-   */
-  static populate(
-    message: Message,
-    signatures: Array<string> = [],
-  ): Transaction {
-    const transaction = new Transaction();
-    transaction.recentBlockhash = message.recentBlockhash;
-    if (message.header.numRequiredSignatures > 0) {
-      transaction.feePayer = message.accountKeys[0];
-    }
-    signatures.forEach((signature, index) => {
-      const sigPubkeyPair = {
-        signature:
-          signature == bs58.encode(DEFAULT_SIGNATURE)
-            ? null
-            : bs58.decode(signature),
-        publicKey: message.accountKeys[index],
-      };
-      transaction.signatures.push(sigPubkeyPair);
-    });
-
-    message.instructions.forEach(instruction => {
-      const keys = instruction.accounts.map(account => {
-        const pubkey = message.accountKeys[account];
-        return {
-          pubkey,
-          isSigner:
-            transaction.signatures.some(
-              keyObj => keyObj.publicKey.toString() === pubkey.toString(),
-            ) || message.isAccountSigner(account),
-          isWritable: message.isAccountWritable(account),
-        };
-      });
-
-      transaction.instructions.push(
-        new TransactionInstruction({
-          keys,
-          programId: message.accountKeys[instruction.programIdIndex],
-          data: bs58.decode(instruction.data),
-        }),
-      );
-    });
-
-    transaction._message = message;
-    transaction._json = transaction.toJSON();
-
-    return transaction;
-  }
-}