@solana/web3.js 1.20.1 → 1.20.3

package/lib/index.esm.js

@@ -7,10 +7,8 @@ import bs58 from 'bs58';
 import { sha256 } from 'crypto-hash';
 import { serialize, deserialize, deserializeUnchecked } from 'borsh';
 import * as BufferLayout from '@solana/buffer-layout';
-import invariant from 'assert';
-import { format, parse } from 'url';
 import fetch from 'node-fetch';
-import { coerce, instance, string, tuple, literal, unknown, union, type, optional, any, number, array, nullable, create, boolean, record, assert } from 'superstruct';
+import { coerce, instance, string, tuple, literal, unknown, union, type, optional, any, number, array, nullable, create, boolean, record, assert as assert$1 } from 'superstruct';
 import { Client } from 'rpc-websockets';
 import RpcClient from 'jayson/lib/client/browser';
 import http from 'http';
@@ -441,6 +439,36 @@ function encodeLength(bytes, len) {
   }
 }
 
+const END_OF_BUFFER_ERROR_MESSAGE = 'Reached end of buffer unexpectedly';
+/**
+ * Delegates to `Array#shift`, but throws if the array is zero-length.
+ */
+
+function guardedShift(byteArray) {
+  if (byteArray.length === 0) {
+    throw new Error(END_OF_BUFFER_ERROR_MESSAGE);
+  }
+
+  return byteArray.shift();
+}
+/**
+ * Delegates to `Array#splice`, but throws if the section being spliced out extends past the end of
+ * the array.
+ */
+
+function guardedSplice(byteArray, ...args) {
+  var _args$;
+
+  const [start] = args;
+
+  if (args.length === 2 // Implies that `deleteCount` was supplied
+  ? start + ((_args$ = args[1]) !== null && _args$ !== void 0 ? _args$ : 0) > byteArray.length : start >= byteArray.length) {
+    throw new Error(END_OF_BUFFER_ERROR_MESSAGE);
+  }
+
+  return byteArray.splice(...args);
+}
+
 /**
  * The message header, identifying signed and read-only account
  */
@@ -525,32 +553,28 @@ class Message {
   static from(buffer) {
     // Slice up wire data
     let byteArray = [...buffer];
-    const numRequiredSignatures = byteArray.shift();
-    const numReadonlySignedAccounts = byteArray.shift();
-    const numReadonlyUnsignedAccounts = byteArray.shift();
+    const numRequiredSignatures = guardedShift(byteArray);
+    const numReadonlySignedAccounts = guardedShift(byteArray);
+    const numReadonlyUnsignedAccounts = guardedShift(byteArray);
     const accountCount = 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 = guardedSplice(byteArray, 0, PUBKEY_LENGTH);
       accountKeys.push(bs58.encode(Buffer.from(account)));
     }
 
-    const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
-    byteArray = byteArray.slice(PUBKEY_LENGTH);
+    const recentBlockhash = guardedSplice(byteArray, 0, PUBKEY_LENGTH);
     const instructionCount = decodeLength(byteArray);
     let instructions = [];
 
     for (let i = 0; i < instructionCount; i++) {
-      const programIdIndex = byteArray.shift();
+      const programIdIndex = guardedShift(byteArray);
       const accountCount = decodeLength(byteArray);
-      const accounts = byteArray.slice(0, accountCount);
-      byteArray = byteArray.slice(accountCount);
+      const accounts = guardedSplice(byteArray, 0, accountCount);
       const dataLength = decodeLength(byteArray);
-      const dataSlice = byteArray.slice(0, dataLength);
+      const dataSlice = guardedSplice(byteArray, 0, dataLength);
       const data = bs58.encode(Buffer.from(dataSlice));
-      byteArray = byteArray.slice(dataLength);
       instructions.push({
         programIdIndex,
         accounts,
@@ -573,6 +597,16 @@ class Message {
 
 }
 
+function assert (condition, message) {
+  if (!condition) {
+    throw new Error(message || 'Assertion failed');
+  }
+}
+
+/**
+ * Transaction signature as base-58 encoded string
+ */
+
 /**
  * Default (empty) signature
  *
@@ -848,8 +882,8 @@ class Transaction {
       };
     });
     instructions.forEach(instruction => {
-      invariant(instruction.programIdIndex >= 0);
-      instruction.accounts.forEach(keyIndex => invariant(keyIndex >= 0));
+      assert(instruction.programIdIndex >= 0);
+      instruction.accounts.forEach(keyIndex => assert(keyIndex >= 0));
     });
     return new Message({
       header: {
@@ -1036,7 +1070,7 @@ class Transaction {
 
 
   _addSignature(pubkey, signature) {
-    invariant(signature.length === 64);
+    assert(signature.length === 64);
     const index = this.signatures.findIndex(sigpair => pubkey.equals(sigpair.publicKey));
 
     if (index < 0) {
@@ -1110,18 +1144,18 @@ class Transaction {
     encodeLength(signatureCount, signatures.length);
     const transactionLength = signatureCount.length + signatures.length * 64 + signData.length;
     const wireTransaction = Buffer.alloc(transactionLength);
-    invariant(signatures.length < 256);
+    assert(signatures.length < 256);
     Buffer.from(signatureCount).copy(wireTransaction, 0);
     signatures.forEach(({
       signature
     }, index) => {
       if (signature !== null) {
-        invariant(signature.length === 64, `signature has invalid length`);
+        assert(signature.length === 64, `signature has invalid length`);
         Buffer.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
       }
     });
     signData.copy(wireTransaction, signatureCount.length + signatures.length * 64);
-    invariant(wireTransaction.length <= PACKET_DATA_SIZE, `Transaction too large: ${wireTransaction.length} > ${PACKET_DATA_SIZE}`);
+    assert(wireTransaction.length <= PACKET_DATA_SIZE, `Transaction too large: ${wireTransaction.length} > ${PACKET_DATA_SIZE}`);
     return wireTransaction;
   }
   /**
@@ -1131,7 +1165,7 @@ class Transaction {
 
 
   get keys() {
-    invariant(this.instructions.length === 1);
+    assert(this.instructions.length === 1);
     return this.instructions[0].keys.map(keyObj => keyObj.pubkey);
   }
   /**
@@ -1141,7 +1175,7 @@ class Transaction {
 
 
   get programId() {
-    invariant(this.instructions.length === 1);
+    assert(this.instructions.length === 1);
     return this.instructions[0].programId;
   }
   /**
@@ -1151,7 +1185,7 @@ class Transaction {
 
 
   get data() {
-    invariant(this.instructions.length === 1);
+    assert(this.instructions.length === 1);
     return this.instructions[0].data;
   }
   /**
@@ -1166,8 +1200,7 @@ class Transaction {
     let signatures = [];
 
     for (let i = 0; i < signatureCount; i++) {
-      const signature = byteArray.slice(0, SIGNATURE_LENGTH);
-      byteArray = byteArray.slice(SIGNATURE_LENGTH);
+      const signature = guardedSplice(byteArray, 0, SIGNATURE_LENGTH);
       signatures.push(bs58.encode(Buffer.from(signature)));
     }
 
@@ -2450,7 +2483,7 @@ function promiseTimeout(promise, timeoutMs) {
 }
 
 function makeWebsocketUrl(endpoint) {
-  let url = parse(endpoint);
+  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
@@ -2460,11 +2493,11 @@ function makeWebsocketUrl(endpoint) {
   // 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 !== null) {
+  if (url.port !== '') {
     url.port = String(Number(url.port) + 1);
   }
 
-  return format(url);
+  return url.toString();
 }
 
 const PublicKeyFromString = coerce(instance(PublicKey), string(), value => new PublicKey(value));
@@ -3418,7 +3451,7 @@ class Connection {
 
     _defineProperty(this, "_slotUpdateSubscriptions", {});
 
-    let url = parse(endpoint);
+    let url = new URL(endpoint);
     const useHttps = url.protocol === 'https:';
     let wsEndpoint;
     let httpHeaders;
@@ -3437,7 +3470,7 @@ class Connection {
 
     this._rpcEndpoint = endpoint;
     this._rpcWsEndpoint = wsEndpoint || makeWebsocketUrl(endpoint);
-    this._rpcClient = createRpcClient(url.href, useHttps, httpHeaders, fetchMiddleware, disableRetryOnRateLimit);
+    this._rpcClient = createRpcClient(url.toString(), useHttps, httpHeaders, fetchMiddleware, disableRetryOnRateLimit);
     this._rpcRequest = createRpcRequest(this._rpcClient);
     this._rpcBatchRequest = createRpcBatchRequest(this._rpcClient);
     this._rpcWebSocket = new Client(this._rpcWsEndpoint, {
@@ -3850,7 +3883,7 @@ class Connection {
       throw new Error('signature must be base58 encoded: ' + signature);
     }
 
-    invariant(decodedSignature.length === 64, 'signature has invalid length');
+    assert(decodedSignature.length === 64, 'signature has invalid length');
     const start = Date.now();
     const subscriptionCommitment = commitment || this.commitment;
     let subscriptionId;
@@ -3993,7 +4026,7 @@ class Connection {
       context,
       value: values
     } = await this.getSignatureStatuses([signature], config);
-    invariant(values.length === 1);
+    assert(values.length === 1);
     const value = values[0];
     return {
       context,
@@ -6287,7 +6320,7 @@ class Secp256k1Program {
    * @param {Buffer} publicKey a 64 byte secp256k1 public key buffer
    */
   static publicKeyToEthAddress(publicKey) {
-    invariant(publicKey.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`);
+    assert(publicKey.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`);
 
     try {
       return Buffer.from(keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
@@ -6340,7 +6373,7 @@ class Secp256k1Program {
       ethAddress = rawAddress;
     }
 
-    invariant(ethAddress.length === ETHEREUM_ADDRESS_BYTES, `Address must be ${ETHEREUM_ADDRESS_BYTES} bytes but received ${ethAddress.length} bytes`);
+    assert(ethAddress.length === ETHEREUM_ADDRESS_BYTES, `Address must be ${ETHEREUM_ADDRESS_BYTES} bytes but received ${ethAddress.length} bytes`);
     const dataStart = 1 + SIGNATURE_OFFSETS_SERIALIZED_SIZE;
     const ethAddressOffset = dataStart;
     const signatureOffset = dataStart + ethAddress.length;
@@ -6378,7 +6411,7 @@ class Secp256k1Program {
       privateKey: pkey,
       message
     } = params;
-    invariant(pkey.length === PRIVATE_KEY_BYTES, `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${pkey.length} bytes`);
+    assert(pkey.length === PRIVATE_KEY_BYTES, `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${pkey.length} bytes`);
 
     try {
       const privateKey = toBuffer(pkey);
@@ -6459,10 +6492,8 @@ class ValidatorInfo {
     const configKeys = [];
 
     for (let i = 0; i < 2; i++) {
-      const publicKey = new PublicKey(byteArray.slice(0, PUBKEY_LENGTH));
-      byteArray = byteArray.slice(PUBKEY_LENGTH);
-      const isSigner = byteArray.slice(0, 1)[0] === 1;
-      byteArray = byteArray.slice(1);
+      const publicKey = new PublicKey(guardedSplice(byteArray, 0, PUBKEY_LENGTH));
+      const isSigner = guardedShift(byteArray) === 1;
       configKeys.push({
         publicKey,
         isSigner
@@ -6473,7 +6504,7 @@ class ValidatorInfo {
       if (configKeys[1].isSigner) {
         const rawInfo = rustString().decode(Buffer.from(byteArray));
         const info = JSON.parse(rawInfo);
-        assert(info, InfoString);
+        assert$1(info, InfoString);
         return new ValidatorInfo(configKeys[1].publicKey, info);
       }
     }