solana-web3-fork 1.0.0

package/src/transaction/message.ts

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,127 @@
+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';
+import {guardedSplice} from '../utils/guarded-array-utils';
+
+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(guardedSplice(byteArray, 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

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

package/src/utils/bigint.ts

@@ -0,0 +1,24 @@
+import {Buffer} from 'buffer';
+import {blob, Layout} from '@solana/buffer-layout';
+import {getU64Codec} from '@solana/codecs-numbers';
+
+export function u64(property?: string): Layout<bigint> {
+  const layout = blob(8 /* bytes */, property);
+  const decode = layout.decode.bind(layout);
+  const encode = layout.encode.bind(layout);
+
+  const bigIntLayout = layout as Layout<unknown> as Layout<bigint>;
+  const codec = getU64Codec();
+
+  bigIntLayout.decode = (buffer: Buffer, offset: number) => {
+    const src = decode(buffer as Uint8Array, offset);
+    return codec.decode(src);
+  };
+
+  bigIntLayout.encode = (bigInt: bigint, buffer: Buffer, offset: number) => {
+    const src = codec.encode(bigInt) as Uint8Array;
+    return encode(src, buffer as Uint8Array, offset);
+  };
+
+  return bigIntLayout;
+}

package/src/utils/borsh-schema.ts

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,35 @@
+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
+ * @param {Cluster} [cluster="devnet"] - The cluster name of the RPC API URL to use. Possible options: 'devnet' | 'testnet' | 'mainnet-beta'
+ * @param {boolean} [tls="http"] - Use TLS when connecting to cluster.
+ *
+ * @returns {string} URL string of the RPC endpoint
+ */
+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

@@ -0,0 +1,43 @@
+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/guarded-array-utils.ts

@@ -0,0 +1,34 @@
+const END_OF_BUFFER_ERROR_MESSAGE = 'Reached end of buffer unexpectedly';
+
+/**
+ * Delegates to `Array#shift`, but throws if the array is zero-length.
+ */
+export function guardedShift<T>(byteArray: T[]): T {
+  if (byteArray.length === 0) {
+    throw new Error(END_OF_BUFFER_ERROR_MESSAGE);
+  }
+  return byteArray.shift() as T;
+}
+
+/**
+ * Delegates to `Array#splice`, but throws if the section being spliced out extends past the end of
+ * the array.
+ */
+export function guardedSplice<T>(
+  byteArray: T[],
+  ...args:
+    | [start: number, deleteCount?: number]
+    | [start: number, deleteCount: number, ...items: T[]]
+): T[] {
+  const [start] = args;
+  if (
+    args.length === 2 // Implies that `deleteCount` was supplied
+      ? start + (args[1] ?? 0) > byteArray.length
+      : start >= byteArray.length
+  ) {
+    throw new Error(END_OF_BUFFER_ERROR_MESSAGE);
+  }
+  return byteArray.splice(
+    ...(args as Parameters<typeof Array.prototype.splice>),
+  );
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,26 @@
+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 explicitly specifying the endpoint port (HTTP-based RPC), assuming
+    // we're directly trying to connect to agave-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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,110 @@
+import type {Buffer} from 'buffer';
+
+import {
+  BlockheightBasedTransactionConfirmationStrategy,
+  Connection,
+  DurableNonceTransactionConfirmationStrategy,
+  TransactionConfirmationStrategy,
+} from '../connection';
+import type {TransactionSignature} from '../transaction';
+import type {ConfirmOptions} from '../connection';
+import {SendTransactionError} from '../errors';
+
+/**
+ * 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) {
+    if (signature != null) {
+      throw new SendTransactionError({
+        action: sendOptions?.skipPreflight ? 'send' : 'simulate',
+        signature: signature,
+        transactionMessage: `Status: (${JSON.stringify(status)})`,
+      });
+    }
+    throw new Error(
+      `Raw transaction ${signature} failed (${JSON.stringify(status)})`,
+    );
+  }
+
+  return signature;
+}