@solana/web3.js 1.53.0 → 1.55.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/web3.js",
-  "version": "1.53.0",
+  "version": "1.55.0",
   "description": "Solana Javascript API",
   "keywords": [
     "api",
@@ -58,7 +58,9 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.12.5",
-    "@ethersproject/sha2": "^5.5.0",
+    "@noble/ed25519": "^1.7.0",
+    "@noble/hashes": "^1.1.2",
+    "@noble/secp256k1": "^1.6.3",
     "@solana/buffer-layout": "^4.0.0",
     "bigint-buffer": "^1.1.5",
     "bn.js": "^5.0.0",
@@ -69,11 +71,8 @@
     "jayson": "^3.4.4",
     "js-sha3": "^0.8.0",
     "node-fetch": "2",
-    "react-native-url-polyfill": "^1.3.0",
     "rpc-websockets": "^7.5.0",
-    "secp256k1": "^4.0.2",
-    "superstruct": "^0.14.2",
-    "tweetnacl": "^1.0.3"
+    "superstruct": "^0.14.2"
   },
   "devDependencies": {
     "@babel/core": "^7.12.13",
@@ -101,7 +100,6 @@
     "@types/mz": "^2.7.3",
     "@types/node": "^17.0.24",
     "@types/node-fetch": "2",
-    "@types/secp256k1": "^4.0.1",
     "@types/sinon": "^10.0.0",
     "@types/sinon-chai": "^3.2.8",
     "@typescript-eslint/eslint-plugin": "^4.14.2",

package/src/account.ts

@@ -1,7 +1,6 @@
-import nacl from 'tweetnacl';
-import type {SignKeyPair as KeyPair} from 'tweetnacl';
-import type {Buffer} from 'buffer';
+import {Buffer} from 'buffer';
 
+import {generatePrivateKey, getPublicKey} from './utils/ed25519';
 import {toBuffer} from './utils/to-buffer';
 import {PublicKey} from './publickey';
 
@@ -12,7 +11,9 @@ import {PublicKey} from './publickey';
  */
 export class Account {
   /** @internal */
-  _keypair: KeyPair;
+  private _publicKey: Buffer;
+  /** @internal */
+  private _secretKey: Buffer;
 
   /**
    * Create a new Account object
@@ -24,9 +25,15 @@ export class Account {
    */
   constructor(secretKey?: Buffer | Uint8Array | Array<number>) {
     if (secretKey) {
-      this._keypair = nacl.sign.keyPair.fromSecretKey(toBuffer(secretKey));
+      const secretKeyBuffer = toBuffer(secretKey);
+      if (secretKey.length !== 64) {
+        throw new Error('bad secret key size');
+      }
+      this._publicKey = secretKeyBuffer.slice(32, 64);
+      this._secretKey = secretKeyBuffer.slice(0, 32);
     } else {
-      this._keypair = nacl.sign.keyPair();
+      this._secretKey = toBuffer(generatePrivateKey());
+      this._publicKey = toBuffer(getPublicKey(this._secretKey));
     }
   }
 
@@ -34,13 +41,15 @@ export class Account {
    * The public key for this account
    */
   get publicKey(): PublicKey {
-    return new PublicKey(this._keypair.publicKey);
+    return new PublicKey(this._publicKey);
   }
 
   /**
-   * The **unencrypted** secret key for this account
+   * The **unencrypted** secret key for this account. The first 32 bytes
+   * 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/
    */
   get secretKey(): Buffer {
-    return toBuffer(this._keypair.secretKey);
+    return Buffer.concat([this._secretKey, this._publicKey], 64);
   }
 }

package/src/connection.ts

@@ -43,7 +43,6 @@ import {
   TransactionExpiredTimeoutError,
 } from './transaction/expiry-custom-errors';
 import {makeWebsocketUrl} from './utils/makeWebsocketUrl';
-import {URL} from './utils/url-impl';
 import type {Blockhash} from './blockhash';
 import type {FeeCalculator} from './fee-calculator';
 import type {TransactionSignature} from './transaction';
@@ -305,6 +304,14 @@ export type BlockheightBasedTransactionConfirmationStrategy = {
   signature: TransactionSignature;
 } & BlockhashWithExpiryBlockHeight;
 
+/* @internal */
+function assertEndpointUrl(putativeUrl: string) {
+  if (/^https?:/.test(putativeUrl) === false) {
+    throw new TypeError('Endpoint URL must start with `http:` or `https:`.');
+  }
+  return putativeUrl;
+}
+
 /** @internal */
 function extractCommitmentFromConfig<TConfig>(
   commitmentOrConfig?: Commitment | ({commitment?: Commitment} & TConfig),
@@ -1117,7 +1124,6 @@ export type PerfSample = {
 
 function createRpcClient(
   url: string,
-  useHttps: boolean,
   httpHeaders?: HttpHeaders,
   customFetch?: FetchFn,
   fetchMiddleware?: FetchMiddleware,
@@ -1126,7 +1132,7 @@ function createRpcClient(
   const fetch = customFetch ? customFetch : fetchImpl;
   let agentManager: AgentManager | undefined;
   if (!process.env.BROWSER) {
-    agentManager = new AgentManager(useHttps);
+    agentManager = new AgentManager(url.startsWith('https:') /* useHttps */);
   }
 
   let fetchWithMiddleware: FetchFn | undefined;
@@ -2493,9 +2499,6 @@ export class Connection {
     endpoint: string,
     commitmentOrConfig?: Commitment | ConnectionConfig,
   ) {
-    let url = new URL(endpoint);
-    const useHttps = url.protocol === 'https:';
-
     let wsEndpoint;
     let httpHeaders;
     let fetch;
@@ -2514,12 +2517,11 @@ export class Connection {
       disableRetryOnRateLimit = commitmentOrConfig.disableRetryOnRateLimit;
     }
 
-    this._rpcEndpoint = endpoint;
+    this._rpcEndpoint = assertEndpointUrl(endpoint);
     this._rpcWsEndpoint = wsEndpoint || makeWebsocketUrl(endpoint);
 
     this._rpcClient = createRpcClient(
-      url.toString(),
-      useHttps,
+      endpoint,
       httpHeaders,
       fetch,
       fetchMiddleware,

package/src/keypair.ts

@@ -1,5 +1,4 @@
-import nacl from 'tweetnacl';
-
+import {generateKeypair, getPublicKey, Ed25519Keypair} from './utils/ed25519';
 import {PublicKey} from './publickey';
 
 /**
@@ -10,14 +9,6 @@ export interface Signer {
   secretKey: Uint8Array;
 }
 
-/**
- * Ed25519 Keypair
- */
-export interface Ed25519Keypair {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-}
-
 /**
  * An account keypair used for signing transactions.
  */
@@ -31,18 +22,14 @@ export class Keypair {
    * @param keypair ed25519 keypair
    */
   constructor(keypair?: Ed25519Keypair) {
-    if (keypair) {
-      this._keypair = keypair;
-    } else {
-      this._keypair = nacl.sign.keyPair();
-    }
+    this._keypair = keypair ?? generateKeypair();
   }
 
   /**
    * Generate a new random keypair
    */
   static generate(): Keypair {
-    return new Keypair(nacl.sign.keyPair());
+    return new Keypair(generateKeypair());
   }
 
   /**
@@ -61,16 +48,20 @@ export class Keypair {
     secretKey: Uint8Array,
     options?: {skipValidation?: boolean},
   ): Keypair {
-    const keypair = nacl.sign.keyPair.fromSecretKey(secretKey);
+    if (secretKey.byteLength !== 64) {
+      throw new Error('bad secret key size');
+    }
+    const publicKey = secretKey.slice(32, 64);
     if (!options || !options.skipValidation) {
-      const encoder = new TextEncoder();
-      const signData = encoder.encode('@solana/web3.js-validation-v1');
-      const signature = nacl.sign.detached(signData, keypair.secretKey);
-      if (!nacl.sign.detached.verify(signData, signature, keypair.publicKey)) {
-        throw new Error('provided secretKey is invalid');
+      const privateScalar = secretKey.slice(0, 32);
+      const computedPublicKey = getPublicKey(privateScalar);
+      for (let ii = 0; ii < 32; ii++) {
+        if (publicKey[ii] !== computedPublicKey[ii]) {
+          throw new Error('provided secretKey is invalid');
+        }
       }
     }
-    return new Keypair(keypair);
+    return new Keypair({publicKey, secretKey});
   }
 
   /**
@@ -79,7 +70,11 @@ export class Keypair {
    * @param seed seed byte array
    */
   static fromSeed(seed: Uint8Array): Keypair {
-    return new Keypair(nacl.sign.keyPair.fromSeed(seed));
+    const publicKey = getPublicKey(seed);
+    const secretKey = new Uint8Array(64);
+    secretKey.set(seed);
+    secretKey.set(publicKey, 32);
+    return new Keypair({publicKey, secretKey});
   }
 
   /**

package/src/layout.ts

@@ -8,6 +8,13 @@ export const publicKey = (property: string = 'publicKey') => {
   return BufferLayout.blob(32, property);
 };
 
+/**
+ * Layout for a signature
+ */
+export const signature = (property: string = 'signature') => {
+  return BufferLayout.blob(64, property);
+};
+
 /**
  * Layout for a 64bit unsigned value
  */

package/src/message/index.ts

@@ -1,4 +1,8 @@
+import {PublicKey} from '../publickey';
+
 export * from './legacy';
+export * from './versioned';
+export * from './v0';
 
 /**
  * The message header, identifying signed and read-only account
@@ -15,18 +19,27 @@ export type MessageHeader = {
   numReadonlyUnsignedAccounts: number;
 };
 
+/**
+ * An address table lookup used to load additional accounts
+ */
+export type MessageAddressTableLookup = {
+  accountKey: PublicKey;
+  writableIndexes: Array<number>;
+  readonlyIndexes: Array<number>;
+};
+
 /**
  * An instruction to execute by a program
  *
  * @property {number} programIdIndex
- * @property {number[]} accounts
- * @property {string} data
+ * @property {number[]} accountKeyIndexes
+ * @property {Uint8Array} data
  */
-export type CompiledInstruction = {
+export type MessageCompiledInstruction = {
   /** Index into the transaction keys array indicating the program account that executes this instruction */
   programIdIndex: number;
   /** Ordered indices into the transaction keys array indicating which accounts to pass to the program */
-  accounts: number[];
-  /** The program input data encoded as base 58 */
-  data: string;
+  accountKeyIndexes: number[];
+  /** The program input data */
+  data: Uint8Array;
 };

package/src/message/legacy.ts

@@ -2,13 +2,33 @@ import bs58 from 'bs58';
 import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
 
-import {PublicKey} from '../publickey';
+import {PublicKey, PUBLIC_KEY_LENGTH} from '../publickey';
 import type {Blockhash} from '../blockhash';
 import * as Layout from '../layout';
-import {PACKET_DATA_SIZE} from '../transaction/constants';
+import {PACKET_DATA_SIZE, VERSION_PREFIX_MASK} from '../transaction/constants';
 import * as shortvec from '../utils/shortvec-encoding';
 import {toBuffer} from '../utils/to-buffer';
-import {CompiledInstruction, MessageHeader} from './index';
+import {
+  MessageHeader,
+  MessageAddressTableLookup,
+  MessageCompiledInstruction,
+} from './index';
+
+/**
+ * An instruction to execute by a program
+ *
+ * @property {number} programIdIndex
+ * @property {number[]} accounts
+ * @property {string} data
+ */
+export type CompiledInstruction = {
+  /** Index into the transaction keys array indicating the program account that executes this instruction */
+  programIdIndex: number;
+  /** Ordered indices into the transaction keys array indicating which accounts to pass to the program */
+  accounts: number[];
+  /** The program input data encoded as base 58 */
+  data: string;
+};
 
 /**
  * Message constructor arguments
@@ -24,8 +44,6 @@ export type MessageArgs = {
   instructions: CompiledInstruction[];
 };
 
-const PUBKEY_LENGTH = 32;
-
 /**
  * List of instructions to be processed atomically
  */
@@ -53,6 +71,28 @@ export class Message {
     );
   }
 
+  get version(): 'legacy' {
+    return 'legacy';
+  }
+
+  get staticAccountKeys(): Array<PublicKey> {
+    return this.accountKeys;
+  }
+
+  get compiledInstructions(): Array<MessageCompiledInstruction> {
+    return this.instructions.map(
+      (ix): MessageCompiledInstruction => ({
+        programIdIndex: ix.programIdIndex,
+        accountKeyIndexes: ix.accounts,
+        data: bs58.decode(ix.data),
+      }),
+    );
+  }
+
+  get addressTableLookups(): Array<MessageAddressTableLookup> {
+    return [];
+  }
+
   isAccountSigner(index: number): boolean {
     return index < this.header.numRequiredSignatures;
   }
@@ -193,19 +233,28 @@ export class Message {
     let byteArray = [...buffer];
 
     const numRequiredSignatures = byteArray.shift() as number;
+    if (
+      numRequiredSignatures !==
+      (numRequiredSignatures & VERSION_PREFIX_MASK)
+    ) {
+      throw new Error(
+        'Versioned messages must be deserialized with VersionedMessage.deserialize()',
+      );
+    }
+
     const numReadonlySignedAccounts = byteArray.shift() as number;
     const numReadonlyUnsignedAccounts = byteArray.shift() as number;
 
     const accountCount = shortvec.decodeLength(byteArray);
     let accountKeys = [];
     for (let i = 0; i < accountCount; i++) {
-      const account = byteArray.slice(0, PUBKEY_LENGTH);
-      byteArray = byteArray.slice(PUBKEY_LENGTH);
+      const account = byteArray.slice(0, PUBLIC_KEY_LENGTH);
+      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
       accountKeys.push(bs58.encode(Buffer.from(account)));
     }
 
-    const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
-    byteArray = byteArray.slice(PUBKEY_LENGTH);
+    const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);
+    byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
 
     const instructionCount = shortvec.decodeLength(byteArray);
     let instructions: CompiledInstruction[] = [];