@solana/web3.js 1.52.0 → 1.54.1

package/src/publickey.ts

@@ -1,17 +1,22 @@
 import BN from 'bn.js';
 import bs58 from 'bs58';
 import {Buffer} from 'buffer';
-import nacl from 'tweetnacl';
-import {sha256} from '@ethersproject/sha2';
+import {sha256} from '@noble/hashes/sha256';
 
-import {Struct, SOLANA_SCHEMA} from './util/borsh-schema';
-import {toBuffer} from './util/to-buffer';
+import {isOnCurve} from './utils/ed25519';
+import {Struct, SOLANA_SCHEMA} from './utils/borsh-schema';
+import {toBuffer} from './utils/to-buffer';
 
 /**
  * Maximum length of derived pubkey seed
  */
 export const MAX_SEED_LENGTH = 32;
 
+/**
+ * Size of public key in bytes
+ */
+export const PUBLIC_KEY_LENGTH = 32;
+
 /**
  * Value to be converted into public key
  */
@@ -54,7 +59,7 @@ export class PublicKey extends Struct {
       if (typeof value === 'string') {
         // assume base 58 encoding by default
         const decoded = bs58.decode(value);
-        if (decoded.length != 32) {
+        if (decoded.length != PUBLIC_KEY_LENGTH) {
           throw new Error(`Invalid public key input`);
         }
         this._bn = new BN(decoded);
@@ -103,7 +108,7 @@ export class PublicKey extends Struct {
    */
   toBuffer(): Buffer {
     const b = this._bn.toArrayLike(Buffer);
-    if (b.length === 32) {
+    if (b.length === PUBLIC_KEY_LENGTH) {
       return b;
     }
 
@@ -135,8 +140,8 @@ export class PublicKey extends Struct {
       Buffer.from(seed),
       programId.toBuffer(),
     ]);
-    const hash = sha256(new Uint8Array(buffer)).slice(2);
-    return new PublicKey(Buffer.from(hash, 'hex'));
+    const publicKeyBytes = sha256(buffer);
+    return new PublicKey(publicKeyBytes);
   }
 
   /**
@@ -159,9 +164,8 @@ export class PublicKey extends Struct {
       programId.toBuffer(),
       Buffer.from('ProgramDerivedAddress'),
     ]);
-    let hash = sha256(new Uint8Array(buffer)).slice(2);
-    let publicKeyBytes = new BN(hash, 16).toArray(undefined, 32);
-    if (is_on_curve(publicKeyBytes)) {
+    const publicKeyBytes = sha256(buffer);
+    if (isOnCurve(publicKeyBytes)) {
       throw new Error(`Invalid seeds, address must fall off the curve`);
     }
     return new PublicKey(publicKeyBytes);
@@ -224,7 +228,7 @@ export class PublicKey extends Struct {
    */
   static isOnCurve(pubkeyData: PublicKeyInitData): boolean {
     const pubkey = new PublicKey(pubkeyData);
-    return is_on_curve(pubkey.toBytes()) == 1;
+    return isOnCurve(pubkey.toBytes());
   }
 }
 
@@ -232,66 +236,3 @@ SOLANA_SCHEMA.set(PublicKey, {
   kind: 'struct',
   fields: [['_bn', 'u256']],
 });
-
-// @ts-ignore
-let naclLowLevel = nacl.lowlevel;
-
-// Check that a pubkey is on the curve.
-// This function and its dependents were sourced from:
-// https://github.com/dchest/tweetnacl-js/blob/f1ec050ceae0861f34280e62498b1d3ed9c350c6/nacl.js#L792
-function is_on_curve(p: any) {
-  var r = [
-    naclLowLevel.gf(),
-    naclLowLevel.gf(),
-    naclLowLevel.gf(),
-    naclLowLevel.gf(),
-  ];
-
-  var t = naclLowLevel.gf(),
-    chk = naclLowLevel.gf(),
-    num = naclLowLevel.gf(),
-    den = naclLowLevel.gf(),
-    den2 = naclLowLevel.gf(),
-    den4 = naclLowLevel.gf(),
-    den6 = naclLowLevel.gf();
-
-  naclLowLevel.set25519(r[2], gf1);
-  naclLowLevel.unpack25519(r[1], p);
-  naclLowLevel.S(num, r[1]);
-  naclLowLevel.M(den, num, naclLowLevel.D);
-  naclLowLevel.Z(num, num, r[2]);
-  naclLowLevel.A(den, r[2], den);
-
-  naclLowLevel.S(den2, den);
-  naclLowLevel.S(den4, den2);
-  naclLowLevel.M(den6, den4, den2);
-  naclLowLevel.M(t, den6, num);
-  naclLowLevel.M(t, t, den);
-
-  naclLowLevel.pow2523(t, t);
-  naclLowLevel.M(t, t, num);
-  naclLowLevel.M(t, t, den);
-  naclLowLevel.M(t, t, den);
-  naclLowLevel.M(r[0], t, den);
-
-  naclLowLevel.S(chk, r[0]);
-  naclLowLevel.M(chk, chk, den);
-  if (neq25519(chk, num)) naclLowLevel.M(r[0], r[0], I);
-
-  naclLowLevel.S(chk, r[0]);
-  naclLowLevel.M(chk, chk, den);
-  if (neq25519(chk, num)) return 0;
-  return 1;
-}
-let gf1 = naclLowLevel.gf([1]);
-let I = naclLowLevel.gf([
-  0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7,
-  0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83,
-]);
-function neq25519(a: any, b: any) {
-  var c = new Uint8Array(32),
-    d = new Uint8Array(32);
-  naclLowLevel.pack25519(c, a);
-  naclLowLevel.pack25519(d, b);
-  return naclLowLevel.crypto_verify_32(c, 0, d, 0);
-}

package/src/{transaction-constants.ts → transaction/constants.ts}

@@ -7,4 +7,6 @@
  */
 export const PACKET_DATA_SIZE = 1280 - 40 - 8;
 
+export const VERSION_PREFIX_MASK = 0x7f;
+
 export const SIGNATURE_LENGTH_IN_BYTES = 64;

package/src/transaction/index.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './expiry-custom-errors';
+export * from './legacy';
+export * from './versioned';

package/src/{transaction.ts → transaction/legacy.ts}

@@ -1,20 +1,17 @@
-import nacl from 'tweetnacl';
 import bs58 from 'bs58';
 import {Buffer} from 'buffer';
 
-import {
-  PACKET_DATA_SIZE,
-  SIGNATURE_LENGTH_IN_BYTES,
-} from './transaction-constants';
-import {Connection} from './connection';
-import {Message} from './message';
-import {PublicKey} from './publickey';
-import * as shortvec from './util/shortvec-encoding';
-import {toBuffer} from './util/to-buffer';
-import invariant from './util/assert';
-import type {Signer} from './keypair';
-import type {Blockhash} from './blockhash';
-import type {CompiledInstruction} from './message';
+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
@@ -661,7 +658,7 @@ export class Transaction {
   _partialSign(message: Message, ...signers: Array<Signer>) {
     const signData = message.serialize();
     signers.forEach(signer => {
-      const signature = nacl.sign.detached(signData, signer.secretKey);
+      const signature = sign(signData, signer.secretKey);
       this._addSignature(signer.publicKey, toBuffer(signature));
     });
   }
@@ -709,9 +706,7 @@ export class Transaction {
           return false;
         }
       } else {
-        if (
-          !nacl.sign.detached.verify(signData, signature, publicKey.toBuffer())
-        ) {
+        if (!verify(signature, signData, publicKey.toBuffer())) {
           return false;
         }
       }

package/src/transaction/versioned.ts

@@ -0,0 +1,105 @@
+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';
+
+export type TransactionVersion = 'legacy' | 0;
+
+/**
+ * Versioned transaction class
+ */
+export class VersionedTransaction {
+  signatures: Array<Uint8Array>;
+  message: VersionedMessage;
+
+  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);
+    }
+  }
+}

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/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/util/__forks__/react-native/url-impl.ts

@@ -1,2 +0,0 @@
-export {default} from 'react-native-url-polyfill';
-export * from 'react-native-url-polyfill';

package/src/util/makeWebsocketUrl.ts

@@ -1,20 +0,0 @@
-import {URL} from './url-impl';
-
-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();
-}

package/src/util/url-impl.ts

@@ -1,2 +0,0 @@
-export const URL = globalThis.URL;
-export const URLSearchParams = globalThis.URLSearchParams;