@solana/web3.js 0.0.0-next → 0.0.0-pr-29130

package/src/utils/ed25519.ts

@@ -0,0 +1,46 @@
+import {sha512} from '@noble/hashes/sha512';
+import * as ed25519 from '@noble/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;
+}
+
+ed25519.utils.sha512Sync = (...m) => sha512(ed25519.utils.concatBytes(...m));
+
+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.sync.getPublicKey;
+export function isOnCurve(publicKey: Uint8Array): boolean {
+  try {
+    ed25519.Point.fromHex(publicKey, true /* strict */);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export const sign = (
+  message: Parameters<typeof ed25519.sync.sign>[0],
+  secretKey: Ed25519SecretKey,
+) => ed25519.sync.sign(message, secretKey.slice(0, 32));
+export const verify = ed25519.sync.verify;

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 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/secp256k1.ts

@@ -0,0 +1,18 @@
+import {hmac} from '@noble/hashes/hmac';
+import {sha256} from '@noble/hashes/sha256';
+import * as secp256k1 from '@noble/secp256k1';
+
+// Supply a synchronous hashing algorithm to make this
+// library interoperable with the synchronous APIs in web3.js.
+secp256k1.utils.hmacSha256Sync = (key: Uint8Array, ...msgs: Uint8Array[]) => {
+  const h = hmac.create(sha256, key);
+  msgs.forEach(msg => h.update(msg));
+  return h.digest();
+};
+
+export const ecdsaSign = (
+  msgHash: Parameters<typeof secp256k1.signSync>[0],
+  privKey: Parameters<typeof secp256k1.signSync>[1],
+) => secp256k1.signSync(msgHash, privKey, {der: false, recovered: true});
+export const isValidPrivateKey = secp256k1.utils.isValidPrivateKey;
+export const publicKeyCreate = secp256k1.getPublicKey;

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

@@ -0,0 +1,105 @@
+import type {Buffer} from 'buffer';
+
+import {
+  BlockheightBasedTransactionConfirmationStrategy,
+  Connection,
+  DurableNonceTransactionConfirmationStrategy,
+} 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 {BlockheightBasedTransactionConfirmationStrategy} confirmationStrategy
+ * @param {ConfirmOptions} [options]
+ * @returns {Promise<TransactionSignature>}
+ */
+export async function sendAndConfirmRawTransaction(
+  connection: Connection,
+  rawTransaction: Buffer,
+  confirmationStrategy: BlockheightBasedTransactionConfirmationStrategy,
+  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:
+    | BlockheightBasedTransactionConfirmationStrategy
+    | DurableNonceTransactionConfirmationStrategy
+    | ConfirmOptions
+    | undefined,
+  maybeConfirmOptions?: ConfirmOptions,
+): Promise<TransactionSignature> {
+  let confirmationStrategy:
+    | BlockheightBasedTransactionConfirmationStrategy
+    | DurableNonceTransactionConfirmationStrategy
+    | 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

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

package/src/validator-info.ts

@@ -7,8 +7,8 @@ import {
 } from 'superstruct';
 
 import * as Layout from './layout';
-import * as shortvec from './util/shortvec-encoding';
-import {PublicKey} from './publickey';
+import * as shortvec from './utils/shortvec-encoding';
+import {PublicKey, PUBLIC_KEY_LENGTH} from './publickey';
 
 export const VALIDATOR_INFO_KEY = new PublicKey(
   'Va1idator1nfo111111111111111111111111111111',
@@ -77,16 +77,14 @@ export class ValidatorInfo {
   static fromConfigData(
     buffer: Buffer | Uint8Array | Array<number>,
   ): ValidatorInfo | null {
-    const PUBKEY_LENGTH = 32;
-
     let byteArray = [...buffer];
     const configKeyCount = shortvec.decodeLength(byteArray);
     if (configKeyCount !== 2) return null;
 
     const configKeys: Array<ConfigKey> = [];
     for (let i = 0; i < 2; i++) {
-      const publicKey = new PublicKey(byteArray.slice(0, PUBKEY_LENGTH));
-      byteArray = byteArray.slice(PUBKEY_LENGTH);
+      const publicKey = new PublicKey(byteArray.slice(0, PUBLIC_KEY_LENGTH));
+      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
       const isSigner = byteArray.slice(0, 1)[0] === 1;
       byteArray = byteArray.slice(1);
       configKeys.push({publicKey, isSigner});

package/src/vote-account.ts

@@ -3,7 +3,7 @@ import type {Buffer} from 'buffer';
 
 import * as Layout from './layout';
 import {PublicKey} from './publickey';
-import {toBuffer} from './util/to-buffer';
+import {toBuffer} from './utils/to-buffer';
 
 export const VOTE_PROGRAM_ID = new PublicKey(
   'Vote111111111111111111111111111111111111111',

package/src/agent-manager.ts

@@ -1,44 +0,0 @@
-import http from 'http';
-import https from 'https';
-
-export const DESTROY_TIMEOUT_MS = 5000;
-
-export class AgentManager {
-  _agent: http.Agent | https.Agent;
-  _activeRequests = 0;
-  _destroyTimeout: ReturnType<typeof setTimeout> | null = null;
-  _useHttps: boolean;
-
-  static _newAgent(useHttps: boolean): http.Agent | https.Agent {
-    const options = {keepAlive: true, maxSockets: 25};
-    if (useHttps) {
-      return new https.Agent(options);
-    } else {
-      return new http.Agent(options);
-    }
-  }
-
-  constructor(useHttps?: boolean) {
-    this._useHttps = useHttps === true;
-    this._agent = AgentManager._newAgent(this._useHttps);
-  }
-
-  requestStart(): http.Agent | https.Agent {
-    this._activeRequests++;
-    if (this._destroyTimeout !== null) {
-      clearTimeout(this._destroyTimeout);
-      this._destroyTimeout = null;
-    }
-    return this._agent;
-  }
-
-  requestEnd() {
-    this._activeRequests--;
-    if (this._activeRequests === 0 && this._destroyTimeout === null) {
-      this._destroyTimeout = setTimeout(() => {
-        this._agent.destroy();
-        this._agent = AgentManager._newAgent(this._useHttps);
-      }, DESTROY_TIMEOUT_MS);
-    }
-  }
-}

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

@@ -1,46 +0,0 @@
-import type {Buffer} from 'buffer';
-
-import {Connection} 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 {ConfirmOptions} [options]
- * @returns {Promise<TransactionSignature>}
- */
-export async function sendAndConfirmRawTransaction(
-  connection: Connection,
-  rawTransaction: Buffer,
-  options?: ConfirmOptions,
-): Promise<TransactionSignature> {
-  const sendOptions = options && {
-    skipPreflight: options.skipPreflight,
-    preflightCommitment: options.preflightCommitment || options.commitment,
-  };
-
-  const signature = await connection.sendRawTransaction(
-    rawTransaction,
-    sendOptions,
-  );
-
-  const status = (
-    await connection.confirmTransaction(
-      signature,
-      options && options.commitment,
-    )
-  ).value;
-
-  if (status.err) {
-    throw new Error(
-      `Raw transaction ${signature} failed (${JSON.stringify(status)})`,
-    );
-  }
-
-  return signature;
-}

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

@@ -1,50 +0,0 @@
-import {Connection} 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,
-): Promise<TransactionSignature> {
-  const sendOptions = options && {
-    skipPreflight: options.skipPreflight,
-    preflightCommitment: options.preflightCommitment || options.commitment,
-    maxRetries: options.maxRetries,
-  };
-
-  const signature = await connection.sendTransaction(
-    transaction,
-    signers,
-    sendOptions,
-  );
-
-  const status = (
-    await connection.confirmTransaction(
-      signature,
-      options && options.commitment,
-    )
-  ).value;
-
-  if (status.err) {
-    throw new Error(
-      `Transaction ${signature} failed (${JSON.stringify(status)})`,
-    );
-  }
-
-  return signature;
-}

package/src/util/url.ts

@@ -1,18 +0,0 @@
-export function makeWebsocketUrl(endpoint: string) {
-  let url = new URL(endpoint);
-  const useHttps = url.protocol === 'https:';
-
-  url.protocol = useHttps ? 'wss:' : 'ws:';
-  url.host = '';
-
-  // 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.
-  if (url.port !== '') {
-    url.port = String(Number(url.port) + 1);
-  }
-  return url.toString();
-}