@solana/web3.js 1.78.0 → 2.0.0-development

package/src/transaction/message.ts

@@ -1,140 +0,0 @@
-import {AccountKeysFromLookups} from '../message/account-keys';
-import assert from '../utils/assert';
-import {toBuffer} from '../utils/to-buffer';
-import {Blockhash} from '../blockhash';
-import {Message, MessageV0, VersionedMessage} from '../message';
-import {PublicKey} from '../publickey';
-import {AddressLookupTableAccount} from '../programs';
-import {AccountMeta, TransactionInstruction} from './legacy';
-
-export type TransactionMessageArgs = {
-  payerKey: PublicKey;
-  instructions: Array<TransactionInstruction>;
-  recentBlockhash: Blockhash;
-};
-
-export type DecompileArgs =
-  | {
-      accountKeysFromLookups: AccountKeysFromLookups;
-    }
-  | {
-      addressLookupTableAccounts: AddressLookupTableAccount[];
-    };
-
-export class TransactionMessage {
-  payerKey: PublicKey;
-  instructions: Array<TransactionInstruction>;
-  recentBlockhash: Blockhash;
-
-  constructor(args: TransactionMessageArgs) {
-    this.payerKey = args.payerKey;
-    this.instructions = args.instructions;
-    this.recentBlockhash = args.recentBlockhash;
-  }
-
-  static decompile(
-    message: VersionedMessage,
-    args?: DecompileArgs,
-  ): TransactionMessage {
-    const {header, compiledInstructions, recentBlockhash} = message;
-
-    const {
-      numRequiredSignatures,
-      numReadonlySignedAccounts,
-      numReadonlyUnsignedAccounts,
-    } = header;
-
-    const numWritableSignedAccounts =
-      numRequiredSignatures - numReadonlySignedAccounts;
-    assert(numWritableSignedAccounts > 0, 'Message header is invalid');
-
-    const numWritableUnsignedAccounts =
-      message.staticAccountKeys.length -
-      numRequiredSignatures -
-      numReadonlyUnsignedAccounts;
-    assert(numWritableUnsignedAccounts >= 0, 'Message header is invalid');
-
-    const accountKeys = message.getAccountKeys(args);
-    const payerKey = accountKeys.get(0);
-    if (payerKey === undefined) {
-      throw new Error(
-        'Failed to decompile message because no account keys were found',
-      );
-    }
-
-    const instructions: TransactionInstruction[] = [];
-    for (const compiledIx of compiledInstructions) {
-      const keys: AccountMeta[] = [];
-
-      for (const keyIndex of compiledIx.accountKeyIndexes) {
-        const pubkey = accountKeys.get(keyIndex);
-        if (pubkey === undefined) {
-          throw new Error(
-            `Failed to find key for account key index ${keyIndex}`,
-          );
-        }
-
-        const isSigner = keyIndex < numRequiredSignatures;
-
-        let isWritable;
-        if (isSigner) {
-          isWritable = keyIndex < numWritableSignedAccounts;
-        } else if (keyIndex < accountKeys.staticAccountKeys.length) {
-          isWritable =
-            keyIndex - numRequiredSignatures < numWritableUnsignedAccounts;
-        } else {
-          isWritable =
-            keyIndex - accountKeys.staticAccountKeys.length <
-            // accountKeysFromLookups cannot be undefined because we already found a pubkey for this index above
-            accountKeys.accountKeysFromLookups!.writable.length;
-        }
-
-        keys.push({
-          pubkey,
-          isSigner: keyIndex < header.numRequiredSignatures,
-          isWritable,
-        });
-      }
-
-      const programId = accountKeys.get(compiledIx.programIdIndex);
-      if (programId === undefined) {
-        throw new Error(
-          `Failed to find program id for program id index ${compiledIx.programIdIndex}`,
-        );
-      }
-
-      instructions.push(
-        new TransactionInstruction({
-          programId,
-          data: toBuffer(compiledIx.data),
-          keys,
-        }),
-      );
-    }
-
-    return new TransactionMessage({
-      payerKey,
-      instructions,
-      recentBlockhash,
-    });
-  }
-
-  compileToLegacyMessage(): Message {
-    return Message.compile({
-      payerKey: this.payerKey,
-      recentBlockhash: this.recentBlockhash,
-      instructions: this.instructions,
-    });
-  }
-
-  compileToV0Message(
-    addressLookupTableAccounts?: AddressLookupTableAccount[],
-  ): MessageV0 {
-    return MessageV0.compile({
-      payerKey: this.payerKey,
-      recentBlockhash: this.recentBlockhash,
-      instructions: this.instructions,
-      addressLookupTableAccounts,
-    });
-  }
-}

package/src/transaction/versioned.ts

@@ -1,126 +0,0 @@
-import * as BufferLayout from '@solana/buffer-layout';
-
-import {Signer} from '../keypair';
-import assert from '../utils/assert';
-import {VersionedMessage} from '../message/versioned';
-import {SIGNATURE_LENGTH_IN_BYTES} from './constants';
-import * as shortvec from '../utils/shortvec-encoding';
-import * as Layout from '../layout';
-import {sign} from '../utils/ed25519';
-import {PublicKey} from '../publickey';
-
-export type TransactionVersion = 'legacy' | 0;
-
-/**
- * Versioned transaction class
- */
-export class VersionedTransaction {
-  signatures: Array<Uint8Array>;
-  message: VersionedMessage;
-
-  get version(): TransactionVersion {
-    return this.message.version;
-  }
-
-  constructor(message: VersionedMessage, signatures?: Array<Uint8Array>) {
-    if (signatures !== undefined) {
-      assert(
-        signatures.length === message.header.numRequiredSignatures,
-        'Expected signatures length to be equal to the number of required signatures',
-      );
-      this.signatures = signatures;
-    } else {
-      const defaultSignatures = [];
-      for (let i = 0; i < message.header.numRequiredSignatures; i++) {
-        defaultSignatures.push(new Uint8Array(SIGNATURE_LENGTH_IN_BYTES));
-      }
-      this.signatures = defaultSignatures;
-    }
-    this.message = message;
-  }
-
-  serialize(): Uint8Array {
-    const serializedMessage = this.message.serialize();
-
-    const encodedSignaturesLength = Array<number>();
-    shortvec.encodeLength(encodedSignaturesLength, this.signatures.length);
-
-    const transactionLayout = BufferLayout.struct<{
-      encodedSignaturesLength: Uint8Array;
-      signatures: Array<Uint8Array>;
-      serializedMessage: Uint8Array;
-    }>([
-      BufferLayout.blob(
-        encodedSignaturesLength.length,
-        'encodedSignaturesLength',
-      ),
-      BufferLayout.seq(
-        Layout.signature(),
-        this.signatures.length,
-        'signatures',
-      ),
-      BufferLayout.blob(serializedMessage.length, 'serializedMessage'),
-    ]);
-
-    const serializedTransaction = new Uint8Array(2048);
-    const serializedTransactionLength = transactionLayout.encode(
-      {
-        encodedSignaturesLength: new Uint8Array(encodedSignaturesLength),
-        signatures: this.signatures,
-        serializedMessage,
-      },
-      serializedTransaction,
-    );
-
-    return serializedTransaction.slice(0, serializedTransactionLength);
-  }
-
-  static deserialize(serializedTransaction: Uint8Array): VersionedTransaction {
-    let byteArray = [...serializedTransaction];
-
-    const signatures = [];
-    const signaturesLength = shortvec.decodeLength(byteArray);
-    for (let i = 0; i < signaturesLength; i++) {
-      signatures.push(
-        new Uint8Array(byteArray.splice(0, SIGNATURE_LENGTH_IN_BYTES)),
-      );
-    }
-
-    const message = VersionedMessage.deserialize(new Uint8Array(byteArray));
-    return new VersionedTransaction(message, signatures);
-  }
-
-  sign(signers: Array<Signer>) {
-    const messageData = this.message.serialize();
-    const signerPubkeys = this.message.staticAccountKeys.slice(
-      0,
-      this.message.header.numRequiredSignatures,
-    );
-    for (const signer of signers) {
-      const signerIndex = signerPubkeys.findIndex(pubkey =>
-        pubkey.equals(signer.publicKey),
-      );
-      assert(
-        signerIndex >= 0,
-        `Cannot sign with non signer key ${signer.publicKey.toBase58()}`,
-      );
-      this.signatures[signerIndex] = sign(messageData, signer.secretKey);
-    }
-  }
-
-  addSignature(publicKey: PublicKey, signature: Uint8Array) {
-    assert(signature.byteLength === 64, 'Signature must be 64 bytes long');
-    const signerPubkeys = this.message.staticAccountKeys.slice(
-      0,
-      this.message.header.numRequiredSignatures,
-    );
-    const signerIndex = signerPubkeys.findIndex(pubkey =>
-      pubkey.equals(publicKey),
-    );
-    assert(
-      signerIndex >= 0,
-      `Can not add signature; \`${publicKey.toBase58()}\` is not required to sign this transaction`,
-    );
-    this.signatures[signerIndex] = signature;
-  }
-}

package/src/utils/assert.ts

@@ -1,8 +0,0 @@
-export default function (
-  condition: unknown,
-  message?: string,
-): asserts condition {
-  if (!condition) {
-    throw new Error(message || 'Assertion failed');
-  }
-}

package/src/utils/bigint.ts

@@ -1,43 +0,0 @@
-import {Buffer} from 'buffer';
-import {blob, Layout} from '@solana/buffer-layout';
-import {toBigIntLE, toBufferLE} from 'bigint-buffer';
-
-interface EncodeDecode<T> {
-  decode(buffer: Buffer, offset?: number): T;
-  encode(src: T, buffer: Buffer, offset?: number): number;
-}
-
-const encodeDecode = <T>(layout: Layout<T>): EncodeDecode<T> => {
-  const decode = layout.decode.bind(layout);
-  const encode = layout.encode.bind(layout);
-  return {decode, encode};
-};
-
-const bigInt =
-  (length: number) =>
-  (property?: string): Layout<bigint> => {
-    const layout = blob(length, property);
-    const {encode, decode} = encodeDecode(layout);
-
-    const bigIntLayout = layout as Layout<unknown> as Layout<bigint>;
-
-    bigIntLayout.decode = (buffer: Buffer, offset: number) => {
-      const src = decode(buffer, offset);
-      return toBigIntLE(Buffer.from(src));
-    };
-
-    bigIntLayout.encode = (bigInt: bigint, buffer: Buffer, offset: number) => {
-      const src = toBufferLE(bigInt, length);
-      return encode(src, buffer, offset);
-    };
-
-    return bigIntLayout;
-  };
-
-export const u64 = bigInt(8);
-
-export const u128 = bigInt(16);
-
-export const u192 = bigInt(24);
-
-export const u256 = bigInt(32);

package/src/utils/borsh-schema.ts

@@ -1,38 +0,0 @@
-import {Buffer} from 'buffer';
-import {serialize, deserialize, deserializeUnchecked} from 'borsh';
-
-// Class wrapping a plain object
-export class Struct {
-  constructor(properties: any) {
-    Object.assign(this, properties);
-  }
-
-  encode(): Buffer {
-    return Buffer.from(serialize(SOLANA_SCHEMA, this));
-  }
-
-  static decode(data: Buffer): any {
-    return deserialize(SOLANA_SCHEMA, this, data);
-  }
-
-  static decodeUnchecked(data: Buffer): any {
-    return deserializeUnchecked(SOLANA_SCHEMA, this, data);
-  }
-}
-
-// Class representing a Rust-compatible enum, since enums are only strings or
-// numbers in pure JS
-export class Enum extends Struct {
-  enum: string = '';
-  constructor(properties: any) {
-    super(properties);
-    if (Object.keys(properties).length !== 1) {
-      throw new Error('Enum can only take single value');
-    }
-    Object.keys(properties).map(key => {
-      this.enum = key;
-    });
-  }
-}
-
-export const SOLANA_SCHEMA: Map<Function, any> = new Map();

package/src/utils/cluster.ts

@@ -1,31 +0,0 @@
-const endpoint = {
-  http: {
-    devnet: 'http://api.devnet.solana.com',
-    testnet: 'http://api.testnet.solana.com',
-    'mainnet-beta': 'http://api.mainnet-beta.solana.com/',
-  },
-  https: {
-    devnet: 'https://api.devnet.solana.com',
-    testnet: 'https://api.testnet.solana.com',
-    'mainnet-beta': 'https://api.mainnet-beta.solana.com/',
-  },
-};
-
-export type Cluster = 'devnet' | 'testnet' | 'mainnet-beta';
-
-/**
- * Retrieves the RPC API URL for the specified cluster
- */
-export function clusterApiUrl(cluster?: Cluster, tls?: boolean): string {
-  const key = tls === false ? 'http' : 'https';
-
-  if (!cluster) {
-    return endpoint[key]['devnet'];
-  }
-
-  const url = endpoint[key][cluster];
-  if (!url) {
-    throw new Error(`Unknown ${key} cluster: ${cluster}`);
-  }
-  return url;
-}

package/src/utils/ed25519.ts

@@ -1,43 +0,0 @@
-import {ed25519} from '@noble/curves/ed25519';
-
-/**
- * A 64 byte secret key, the first 32 bytes of which is the
- * private scalar and the last 32 bytes is the public key.
- * Read more: https://blog.mozilla.org/warner/2011/11/29/ed25519-keys/
- */
-type Ed25519SecretKey = Uint8Array;
-
-/**
- * Ed25519 Keypair
- */
-export interface Ed25519Keypair {
-  publicKey: Uint8Array;
-  secretKey: Ed25519SecretKey;
-}
-
-export const generatePrivateKey = ed25519.utils.randomPrivateKey;
-export const generateKeypair = (): Ed25519Keypair => {
-  const privateScalar = ed25519.utils.randomPrivateKey();
-  const publicKey = getPublicKey(privateScalar);
-  const secretKey = new Uint8Array(64);
-  secretKey.set(privateScalar);
-  secretKey.set(publicKey, 32);
-  return {
-    publicKey,
-    secretKey,
-  };
-};
-export const getPublicKey = ed25519.getPublicKey;
-export function isOnCurve(publicKey: Uint8Array): boolean {
-  try {
-    ed25519.ExtendedPoint.fromHex(publicKey);
-    return true;
-  } catch {
-    return false;
-  }
-}
-export const sign = (
-  message: Parameters<typeof ed25519.sign>[0],
-  secretKey: Ed25519SecretKey,
-) => ed25519.sign(message, secretKey.slice(0, 32));
-export const verify = ed25519.verify;

package/src/utils/index.ts

@@ -1,5 +0,0 @@
-export * from './borsh-schema';
-export * from './cluster';
-export type {Ed25519Keypair} from './ed25519';
-export * from './send-and-confirm-raw-transaction';
-export * from './send-and-confirm-transaction';

package/src/utils/makeWebsocketUrl.ts

@@ -1,26 +0,0 @@
-const URL_RE = /^[^:]+:\/\/([^:[]+|\[[^\]]+\])(:\d+)?(.*)/i;
-
-export function makeWebsocketUrl(endpoint: string) {
-  const matches = endpoint.match(URL_RE);
-  if (matches == null) {
-    throw TypeError(`Failed to validate endpoint URL \`${endpoint}\``);
-  }
-  const [
-    _, // eslint-disable-line @typescript-eslint/no-unused-vars
-    hostish,
-    portWithColon,
-    rest,
-  ] = matches;
-  const protocol = endpoint.startsWith('https:') ? 'wss:' : 'ws:';
-  const startPort =
-    portWithColon == null ? null : parseInt(portWithColon.slice(1), 10);
-  const websocketPort =
-    // Only shift the port by +1 as a convention for ws(s) only if given endpoint
-    // is explictly specifying the endpoint port (HTTP-based RPC), assuming
-    // we're directly trying to connect to solana-validator's ws listening port.
-    // When the endpoint omits the port, we're connecting to the protocol
-    // default ports: http(80) or https(443) and it's assumed we're behind a reverse
-    // proxy which manages WebSocket upgrade and backend port redirection.
-    startPort == null ? '' : `:${startPort + 1}`;
-  return `${protocol}//${hostish}${websocketPort}${rest}`;
-}

package/src/utils/promise-timeout.ts

@@ -1,14 +0,0 @@
-export function promiseTimeout<T>(
-  promise: Promise<T>,
-  timeoutMs: number,
-): Promise<T | null> {
-  let timeoutId: ReturnType<typeof setTimeout>;
-  const timeoutPromise: Promise<null> = new Promise(resolve => {
-    timeoutId = setTimeout(() => resolve(null), timeoutMs);
-  });
-
-  return Promise.race([promise, timeoutPromise]).then((result: T | null) => {
-    clearTimeout(timeoutId);
-    return result;
-  });
-}

package/src/utils/secp256k1.ts

@@ -1,11 +0,0 @@
-import {secp256k1} from '@noble/curves/secp256k1';
-
-export const ecdsaSign = (
-  msgHash: Parameters<typeof secp256k1.sign>[0],
-  privKey: Parameters<typeof secp256k1.sign>[1],
-) => {
-  const signature = secp256k1.sign(msgHash, privKey);
-  return [signature.toCompactRawBytes(), signature.recovery!] as const;
-};
-export const isValidPrivateKey = secp256k1.utils.isValidPrivateKey;
-export const publicKeyCreate = secp256k1.getPublicKey;

package/src/utils/send-and-confirm-raw-transaction.ts

@@ -1,102 +0,0 @@
-import type {Buffer} from 'buffer';
-
-import {
-  BlockheightBasedTransactionConfirmationStrategy,
-  Connection,
-  DurableNonceTransactionConfirmationStrategy,
-  TransactionConfirmationStrategy,
-} from '../connection';
-import type {TransactionSignature} from '../transaction';
-import type {ConfirmOptions} from '../connection';
-
-/**
- * Send and confirm a raw transaction
- *
- * If `commitment` option is not specified, defaults to 'max' commitment.
- *
- * @param {Connection} connection
- * @param {Buffer} rawTransaction
- * @param {TransactionConfirmationStrategy} confirmationStrategy
- * @param {ConfirmOptions} [options]
- * @returns {Promise<TransactionSignature>}
- */
-export async function sendAndConfirmRawTransaction(
-  connection: Connection,
-  rawTransaction: Buffer,
-  confirmationStrategy: TransactionConfirmationStrategy,
-  options?: ConfirmOptions,
-): Promise<TransactionSignature>;
-
-/**
- * @deprecated Calling `sendAndConfirmRawTransaction()` without a `confirmationStrategy`
- * is no longer supported and will be removed in a future version.
- */
-// eslint-disable-next-line no-redeclare
-export async function sendAndConfirmRawTransaction(
-  connection: Connection,
-  rawTransaction: Buffer,
-  options?: ConfirmOptions,
-): Promise<TransactionSignature>;
-
-// eslint-disable-next-line no-redeclare
-export async function sendAndConfirmRawTransaction(
-  connection: Connection,
-  rawTransaction: Buffer,
-  confirmationStrategyOrConfirmOptions:
-    | TransactionConfirmationStrategy
-    | ConfirmOptions
-    | undefined,
-  maybeConfirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature> {
-  let confirmationStrategy: TransactionConfirmationStrategy | undefined;
-  let options: ConfirmOptions | undefined;
-  if (
-    confirmationStrategyOrConfirmOptions &&
-    Object.prototype.hasOwnProperty.call(
-      confirmationStrategyOrConfirmOptions,
-      'lastValidBlockHeight',
-    )
-  ) {
-    confirmationStrategy =
-      confirmationStrategyOrConfirmOptions as BlockheightBasedTransactionConfirmationStrategy;
-    options = maybeConfirmOptions;
-  } else if (
-    confirmationStrategyOrConfirmOptions &&
-    Object.prototype.hasOwnProperty.call(
-      confirmationStrategyOrConfirmOptions,
-      'nonceValue',
-    )
-  ) {
-    confirmationStrategy =
-      confirmationStrategyOrConfirmOptions as DurableNonceTransactionConfirmationStrategy;
-    options = maybeConfirmOptions;
-  } else {
-    options = confirmationStrategyOrConfirmOptions as
-      | ConfirmOptions
-      | undefined;
-  }
-  const sendOptions = options && {
-    skipPreflight: options.skipPreflight,
-    preflightCommitment: options.preflightCommitment || options.commitment,
-    minContextSlot: options.minContextSlot,
-  };
-
-  const signature = await connection.sendRawTransaction(
-    rawTransaction,
-    sendOptions,
-  );
-
-  const commitment = options && options.commitment;
-  const confirmationPromise = confirmationStrategy
-    ? connection.confirmTransaction(confirmationStrategy, commitment)
-    : connection.confirmTransaction(signature, commitment);
-  const status = (await confirmationPromise).value;
-
-  if (status.err) {
-    throw new Error(
-      `Raw transaction ${signature} failed (${JSON.stringify(status)})`,
-    );
-  }
-
-  return signature;
-}

package/src/utils/send-and-confirm-transaction.ts

@@ -1,98 +0,0 @@
-import {Connection, SignatureResult} from '../connection';
-import {Transaction} from '../transaction';
-import type {ConfirmOptions} from '../connection';
-import type {Signer} from '../keypair';
-import type {TransactionSignature} from '../transaction';
-
-/**
- * Sign, send and confirm a transaction.
- *
- * If `commitment` option is not specified, defaults to 'max' commitment.
- *
- * @param {Connection} connection
- * @param {Transaction} transaction
- * @param {Array<Signer>} signers
- * @param {ConfirmOptions} [options]
- * @returns {Promise<TransactionSignature>}
- */
-export async function sendAndConfirmTransaction(
-  connection: Connection,
-  transaction: Transaction,
-  signers: Array<Signer>,
-  options?: ConfirmOptions &
-    Readonly<{
-      // A signal that, when aborted, cancels any outstanding transaction confirmation operations
-      abortSignal?: AbortSignal;
-    }>,
-): Promise<TransactionSignature> {
-  const sendOptions = options && {
-    skipPreflight: options.skipPreflight,
-    preflightCommitment: options.preflightCommitment || options.commitment,
-    maxRetries: options.maxRetries,
-    minContextSlot: options.minContextSlot,
-  };
-
-  const signature = await connection.sendTransaction(
-    transaction,
-    signers,
-    sendOptions,
-  );
-
-  let status: SignatureResult;
-  if (
-    transaction.recentBlockhash != null &&
-    transaction.lastValidBlockHeight != null
-  ) {
-    status = (
-      await connection.confirmTransaction(
-        {
-          abortSignal: options?.abortSignal,
-          signature: signature,
-          blockhash: transaction.recentBlockhash,
-          lastValidBlockHeight: transaction.lastValidBlockHeight,
-        },
-        options && options.commitment,
-      )
-    ).value;
-  } else if (
-    transaction.minNonceContextSlot != null &&
-    transaction.nonceInfo != null
-  ) {
-    const {nonceInstruction} = transaction.nonceInfo;
-    const nonceAccountPubkey = nonceInstruction.keys[0].pubkey;
-    status = (
-      await connection.confirmTransaction(
-        {
-          abortSignal: options?.abortSignal,
-          minContextSlot: transaction.minNonceContextSlot,
-          nonceAccountPubkey,
-          nonceValue: transaction.nonceInfo.nonce,
-          signature,
-        },
-        options && options.commitment,
-      )
-    ).value;
-  } else {
-    if (options?.abortSignal != null) {
-      console.warn(
-        'sendAndConfirmTransaction(): A transaction with a deprecated confirmation strategy was ' +
-          'supplied along with an `abortSignal`. Only transactions having `lastValidBlockHeight` ' +
-          'or a combination of `nonceInfo` and `minNonceContextSlot` are abortable.',
-      );
-    }
-    status = (
-      await connection.confirmTransaction(
-        signature,
-        options && options.commitment,
-      )
-    ).value;
-  }
-
-  if (status.err) {
-    throw new Error(
-      `Transaction ${signature} failed (${JSON.stringify(status)})`,
-    );
-  }
-
-  return signature;
-}