@solana/web3.js 1.35.1 → 1.37.1

package/lib/index.cjs.js

@@ -81,32 +81,38 @@ var inherits_browser = {exports: {}};
 if (typeof Object.create === 'function') {
   // implementation from standard node.js 'util' module
   inherits_browser.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor;
-    ctor.prototype = Object.create(superCtor.prototype, {
-      constructor: {
-        value: ctor,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        }
+      });
+    }
   };
 } else {
   // old school shim for old browsers
   inherits_browser.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor;
-    var TempCtor = function () {};
-    TempCtor.prototype = superCtor.prototype;
-    ctor.prototype = new TempCtor();
-    ctor.prototype.constructor = ctor;
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      var TempCtor = function () {};
+      TempCtor.prototype = superCtor.prototype;
+      ctor.prototype = new TempCtor();
+      ctor.prototype.constructor = ctor;
+    }
   };
 }
 
 try {
   var util = require('util');
+  /* istanbul ignore next */
   if (typeof util.inherits !== 'function') throw '';
   inherits$1.exports = util.inherits;
 } catch (e) {
+  /* istanbul ignore next */
   inherits$1.exports = inherits_browser.exports;
 }
 
@@ -1319,7 +1325,7 @@ hash.ripemd160 = hash.ripemd.ripemd160;
 
 var hash = hash$1;
 
-const version$2 = "logger/5.5.0";
+const version$2 = "logger/5.6.0";
 
 let _permanentCensorErrors = false;
 let _censorErrors = false;
@@ -1498,6 +1504,40 @@ class Logger {
         messageDetails.push(`code=${code}`);
         messageDetails.push(`version=${this.version}`);
         const reason = message;
+        let url = "";
+        switch (code) {
+            case ErrorCode.NUMERIC_FAULT: {
+                url = "NUMERIC_FAULT";
+                const fault = message;
+                switch (fault) {
+                    case "overflow":
+                    case "underflow":
+                    case "division-by-zero":
+                        url += "-" + fault;
+                        break;
+                    case "negative-power":
+                    case "negative-width":
+                        url += "-unsupported";
+                        break;
+                    case "unbound-bitwise-result":
+                        url += "-unbound-result";
+                        break;
+                }
+                break;
+            }
+            case ErrorCode.CALL_EXCEPTION:
+            case ErrorCode.INSUFFICIENT_FUNDS:
+            case ErrorCode.MISSING_NEW:
+            case ErrorCode.NONCE_EXPIRED:
+            case ErrorCode.REPLACEMENT_UNDERPRICED:
+            case ErrorCode.TRANSACTION_REPLACED:
+            case ErrorCode.UNPREDICTABLE_GAS_LIMIT:
+                url = code;
+                break;
+        }
+        if (url) {
+            message += " [ See: https:/\/links.ethers.org/v5-errors-" + url + " ]";
+        }
         if (messageDetails.length) {
             message += " (" + messageDetails.join(", ") + ")";
         }
@@ -1631,7 +1671,7 @@ class Logger {
 Logger.errors = ErrorCode;
 Logger.levels = LogLevel;
 
-const version$1 = "bytes/5.5.0";
+const version$1 = "bytes/5.6.0";
 
 const logger = new Logger(version$1);
 ///////////////////////////////
@@ -1728,7 +1768,7 @@ function isHexString(value, length) {
     return true;
 }
 
-const version = "sha2/5.5.0";
+const version = "sha2/5.6.0";
 
 new Logger(version);
 function sha256(data) {
@@ -2066,10 +2106,10 @@ const BPF_LOADER_DEPRECATED_PROGRAM_ID = new PublicKey('BPFLoader111111111111111
 const publicKey = (property = 'publicKey') => {
   return BufferLayout__namespace.blob(32, property);
 };
+
 /**
  * Layout for a Rust String type
  */
-
 const rustString = (property = 'string') => {
   const rsl = BufferLayout__namespace.struct([BufferLayout__namespace.u32('length'), BufferLayout__namespace.u32('lengthPadding'), BufferLayout__namespace.blob(BufferLayout__namespace.offset(BufferLayout__namespace.u32(), -8), 'chars')], property);
 
@@ -2077,24 +2117,26 @@ const rustString = (property = 'string') => {
 
   const _encode = rsl.encode.bind(rsl);
 
-  rsl.decode = (buffer, offset) => {
-    const data = _decode(buffer, offset);
+  const rslShim = rsl;
 
-    return data['chars'].toString('utf8');
+  rslShim.decode = (b, offset) => {
+    const data = _decode(b, offset);
+
+    return data['chars'].toString();
   };
 
-  rsl.encode = (str, buffer$1, offset) => {
+  rslShim.encode = (str, b, offset) => {
     const data = {
       chars: buffer.Buffer.from(str, 'utf8')
     };
-    return _encode(data, buffer$1, offset);
+    return _encode(data, b, offset);
   };
 
-  rsl.alloc = str => {
+  rslShim.alloc = str => {
     return BufferLayout__namespace.u32().span + BufferLayout__namespace.u32().span + buffer.Buffer.from(str, 'utf8').length;
   };
 
-  return rsl;
+  return rslShim;
 };
 /**
  * Layout for an Authorized object
@@ -2214,7 +2256,7 @@ class Message {
         accounts,
         programIdIndex
       } = instruction;
-      const data = bs58__default["default"].decode(instruction.data);
+      const data = Array.from(bs58__default["default"].decode(instruction.data));
       let keyIndicesCount = [];
       encodeLength(keyIndicesCount, accounts.length);
       let dataCount = [];
@@ -2222,7 +2264,7 @@ class Message {
       return {
         programIdIndex,
         keyIndicesCount: buffer.Buffer.from(keyIndicesCount),
-        keyIndices: buffer.Buffer.from(accounts),
+        keyIndices: accounts,
         dataLength: buffer.Buffer.from(dataCount),
         data
       };
@@ -2626,6 +2668,14 @@ class Transaction {
   serializeMessage() {
     return this._compile().serialize();
   }
+  /**
+   * Get the estimated fee associated with a transaction
+   */
+
+
+  async getEstimatedFee(connection) {
+    return (await connection.getFeeForMessage(this.compileMessage())).value;
+  }
   /**
    * Specify the public keys which will be used to sign the Transaction.
    * The first signer will be used as the transaction fee payer account.
@@ -2989,10 +3039,6 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-/**
- * @internal
- */
-
 /**
  * Populate a buffer of instruction data using an InstructionType
  * @internal
@@ -3792,11 +3838,11 @@ class SystemProgram {
 }
 SystemProgram.programId = new PublicKey('11111111111111111111111111111111');
 
+// Keep program chunks under PACKET_DATA_SIZE, leaving enough room for the
 // rest of the Transaction fields
 //
 // TODO: replace 300 with a proper constant for the size of the other
 // Transaction fields
-
 const CHUNK_SIZE = PACKET_DATA_SIZE - 300;
 /**
  * Program loader interface
@@ -3904,7 +3950,9 @@ class Loader {
         instruction: 0,
         // Load instruction
         offset,
-        bytes
+        bytes: bytes,
+        bytesLength: 0,
+        bytesLengthPadding: 0
       }, data);
       const transaction = new Transaction().add({
         keys: [{
@@ -4364,6 +4412,20 @@ const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(superstruct.t
   unitsConsumed: superstruct.optional(superstruct.number())
 }));
 
+/**
+ * Expected JSON RPC response for the "getBlockProduction" message
+ */
+const BlockProductionResponseStruct = jsonRpcResultAndContext(superstruct.type({
+  byIdentity: superstruct.record(superstruct.string(), superstruct.array(superstruct.number())),
+  range: superstruct.type({
+    firstSlot: superstruct.number(),
+    lastSlot: superstruct.number()
+  })
+}));
+/**
+ * A performance sample
+ */
+
 function createRpcClient(url, useHttps, httpHeaders, fetchMiddleware, disableRetryOnRateLimit) {
   let agentManager;
 
@@ -5224,6 +5286,14 @@ class Connection {
   get commitment() {
     return this._commitment;
   }
+  /**
+   * The RPC endpoint
+   */
+
+
+  get rpcEndpoint() {
+    return this._rpcEndpoint;
+  }
   /**
    * Fetch the balance for the specified public key, return with context
    */
@@ -5509,35 +5579,32 @@ class Connection {
     }
   }
   /**
-   * Fetch all the account info for multiple accounts specified by an array of public keys
+   * Fetch all the account info for multiple accounts specified by an array of public keys, return with context
    */
 
 
-  async getMultipleAccountsInfo(publicKeys, configOrCommitment) {
+  async getMultipleAccountsInfoAndContext(publicKeys, commitment) {
     const keys = publicKeys.map(key => key.toBase58());
-    let commitment;
-    let encoding = 'base64';
 
-    if (configOrCommitment) {
-      if (typeof configOrCommitment === 'string') {
-        commitment = configOrCommitment;
-        encoding = 'base64';
-      } else {
-        commitment = configOrCommitment.commitment;
-        encoding = configOrCommitment.encoding || 'base64';
-      }
-    }
-
-    const args = this._buildArgs([keys], commitment, encoding);
+    const args = this._buildArgs([keys], commitment, 'base64');
 
     const unsafeRes = await this._rpcRequest('getMultipleAccounts', args);
-    const res = superstruct.create(unsafeRes, jsonRpcResultAndContext(superstruct.array(superstruct.nullable(ParsedAccountInfoResult))));
+    const res = superstruct.create(unsafeRes, jsonRpcResultAndContext(superstruct.array(superstruct.nullable(AccountInfoResult))));
 
     if ('error' in res) {
       throw new Error('failed to get info for accounts ' + keys + ': ' + res.error.message);
     }
 
-    return res.result.value;
+    return res.result;
+  }
+  /**
+   * Fetch all the account info for multiple accounts specified by an array of public keys
+   */
+
+
+  async getMultipleAccountsInfo(publicKeys, commitment) {
+    const res = await this.getMultipleAccountsInfoAndContext(publicKeys, commitment);
+    return res.value;
   }
   /**
    * Returns epoch activation information for a stake account that has been delegated
@@ -6149,6 +6216,54 @@ class Connection {
       })
     };
   }
+  /*
+   * Returns the current block height of the node
+   */
+
+
+  async getBlockHeight(commitment) {
+    const args = this._buildArgs([], commitment);
+
+    const unsafeRes = await this._rpcRequest('getBlockHeight', args);
+    const res = superstruct.create(unsafeRes, jsonRpcResult(superstruct.number()));
+
+    if ('error' in res) {
+      throw new Error('failed to get block height information: ' + res.error.message);
+    }
+
+    return res.result;
+  }
+  /*
+   * Returns recent block production information from the current or previous epoch
+   */
+
+
+  async getBlockProduction(configOrCommitment) {
+    let extra;
+    let commitment;
+
+    if (typeof configOrCommitment === 'string') {
+      commitment = configOrCommitment;
+    } else if (configOrCommitment) {
+      const {
+        commitment: c,
+        ...rest
+      } = configOrCommitment;
+      commitment = c;
+      extra = rest;
+    }
+
+    const args = this._buildArgs([], commitment, 'base64', extra);
+
+    const unsafeRes = await this._rpcRequest('getBlockProduction', args);
+    const res = superstruct.create(unsafeRes, BlockProductionResponseStruct);
+
+    if ('error' in res) {
+      throw new Error('failed to get block production information: ' + res.error.message);
+    }
+
+    return res.result;
+  }
   /**
    * Fetch a confirmed or finalized transaction from the cluster.
    */
@@ -6809,12 +6924,6 @@ class Connection {
 
       if ('data' in res.error) {
         logs = res.error.data.logs;
-
-        if (logs && Array.isArray(logs)) {
-          const traceIndent = '\n    ';
-          const logTrace = traceIndent + logs.join(traceIndent);
-          console.error(res.error.message, logTrace);
-        }
       }
 
       throw new SendTransactionError('failed to send transaction: ' + res.error.message, logs);
@@ -7630,16 +7739,18 @@ class Ed25519Program {
     const messageDataOffset = signatureOffset + signature.length;
     const numSignatures = 1;
     const instructionData = buffer.Buffer.alloc(messageDataOffset + message.length);
+    const index = instructionIndex == null ? 0xffff // An index of `u16::MAX` makes it default to the current instruction.
+    : instructionIndex;
     ED25519_INSTRUCTION_LAYOUT.encode({
       numSignatures,
       padding: 0,
       signatureOffset,
-      signatureInstructionIndex: instructionIndex,
+      signatureInstructionIndex: index,
       publicKeyOffset,
-      publicKeyInstructionIndex: instructionIndex,
+      publicKeyInstructionIndex: index,
       messageDataOffset,
       messageDataSize: message.length,
-      messageInstructionIndex: instructionIndex
+      messageInstructionIndex: index
     }, instructionData);
     instructionData.fill(publicKey, publicKeyOffset);
     instructionData.fill(signature, signatureOffset);
@@ -7710,10 +7821,10 @@ class Authorized {
   }
 
 }
+
 /**
  * Stake account lockup info
  */
-
 class Lockup {
   /** Unix timestamp of lockup expiration */
 
@@ -7738,10 +7849,6 @@ class Lockup {
 
 
 }
-/**
- * Create stake account transaction params
- */
-
 Lockup.default = new Lockup(0, 0, PublicKey.default);
 
 /**
@@ -8769,8 +8876,8 @@ class VoteAccount {
 }
 
 function parseAuthorizedVoter({
-  epoch,
-  authorizedVoter
+  authorizedVoter,
+  epoch
 }) {
   return {
     epoch,
@@ -8799,7 +8906,7 @@ function getPriorVoters({
     return [];
   }
 
-  return [...buf.slice(idx + 1).map(parsePriorVoters), ...buf.slice(0, idx)];
+  return [...buf.slice(idx + 1).map(parsePriorVoters), ...buf.slice(0, idx).map(parsePriorVoters)];
 }
 
 /**