@solana/web3.js 1.35.1 → 1.37.1

package/lib/index.d.ts

@@ -456,6 +456,10 @@ declare module '@solana/web3.js' {
      * Get a buffer of the Transaction data that need to be covered by signatures
      */
     serializeMessage(): Buffer;
+    /**
+     * Get the estimated fee associated with a transaction
+     */
+    getEstimatedFee(connection: Connection): Promise<number>;
     /**
      * Specify the public keys which will be used to sign the Transaction.
      * The first signer will be used as the transaction fee payer account.
@@ -998,6 +1002,33 @@ declare module '@solana/web3.js' {
     /** The unix timestamp of when the block was processed */
     blockTime: number | null;
   };
+  /**
+   * recent block production information
+   */
+  export type BlockProduction = Readonly<{
+    /** a dictionary of validator identities, as base-58 encoded strings. Value is a two element array containing the number of leader slots and the number of blocks produced */
+    byIdentity: Readonly<Record<string, ReadonlyArray<number>>>;
+    /** Block production slot range */
+    range: Readonly<{
+      /** first slot of the block production information (inclusive) */
+      firstSlot: number;
+      /** last slot of block production information (inclusive) */
+      lastSlot: number;
+    }>;
+  }>;
+  export type GetBlockProductionConfig = {
+    /** Optional commitment level */
+    commitment?: Commitment;
+    /** Slot range to return block production for. If parameter not provided, defaults to current epoch. */
+    range?: {
+      /** first slot to return block production information for (inclusive) */
+      firstSlot: number;
+      /** last slot to return block production information for (inclusive). If parameter not provided, defaults to the highest slot */
+      lastSlot?: number;
+    };
+    /** Only return results for this validator identity (base-58 encoded) */
+    identity?: string;
+  };
   /**
    * A performance sample
    */
@@ -1389,7 +1420,7 @@ declare module '@solana/web3.js' {
     httpHeaders?: HttpHeaders;
     /** Optional fetch middleware callback */
     fetchMiddleware?: FetchMiddleware;
-    /** Optional Disable retring calls when server responds with HTTP 429 (Too Many Requests) */
+    /** Optional Disable retrying calls when server responds with HTTP 429 (Too Many Requests) */
     disableRetryOnRateLimit?: boolean;
     /** time to allow for the server to initially process a transaction (in milliseconds) */
     confirmTransactionInitialTimeout?: number;
@@ -1412,6 +1443,10 @@ declare module '@solana/web3.js' {
      * The default commitment used for requests
      */
     get commitment(): Commitment | undefined;
+    /**
+     * The RPC endpoint
+     */
+    get rpcEndpoint(): string;
     /**
      * Fetch the balance for the specified public key, return with context
      */
@@ -1527,13 +1562,20 @@ declare module '@solana/web3.js' {
       publicKey: PublicKey,
       commitment?: Commitment,
     ): Promise<AccountInfo<Buffer> | null>;
+    /**
+     * Fetch all the account info for multiple accounts specified by an array of public keys, return with context
+     */
+    getMultipleAccountsInfoAndContext(
+      publicKeys: PublicKey[],
+      commitment?: Commitment,
+    ): Promise<RpcResponseAndContext<(AccountInfo<Buffer> | null)[]>>;
     /**
      * Fetch all the account info for multiple accounts specified by an array of public keys
      */
     getMultipleAccountsInfo(
       publicKeys: PublicKey[],
-      configOrCommitment?: GetMultipleAccountsConfig | Commitment,
-    ): Promise<(AccountInfo<Buffer | ParsedAccountData> | null)[]>;
+      commitment?: Commitment,
+    ): Promise<(AccountInfo<Buffer> | null)[]>;
     /**
      * Returns epoch activation information for a stake account that has been delegated
      */
@@ -1735,6 +1777,10 @@ declare module '@solana/web3.js' {
         commitment?: Finality;
       },
     ): Promise<BlockResponse | null>;
+    getBlockHeight(commitment?: Commitment): Promise<number>;
+    getBlockProduction(
+      configOrCommitment?: GetBlockProductionConfig | Commitment,
+    ): Promise<RpcResponseAndContext<BlockProduction>>;
     /**
      * Fetch a confirmed or finalized transaction from the cluster.
      */
@@ -2373,14 +2419,14 @@ declare module '@solana/web3.js' {
    * An enumeration of valid StakeInstructionType's
    */
   export type StakeInstructionType =
-    | 'AuthorizeWithSeed'
     | 'Authorize'
+    | 'AuthorizeWithSeed'
     | 'Deactivate'
     | 'Delegate'
     | 'Initialize'
+    | 'Merge'
     | 'Split'
-    | 'Withdraw'
-    | 'Merge';
+    | 'Withdraw';
   /**
    * Stake authorization type
    */
@@ -2922,24 +2968,24 @@ declare module '@solana/web3.js' {
   /**
    * History of how many credits earned by the end of each epoch
    */
-  export type EpochCredits = {
+  export type EpochCredits = Readonly<{
     epoch: number;
     credits: number;
     prevCredits: number;
-  };
-  export type AuthorizedVoter = {
+  }>;
+  export type AuthorizedVoter = Readonly<{
     epoch: number;
     authorizedVoter: PublicKey;
-  };
-  export type PriorVoter = {
+  }>;
+  export type PriorVoter = Readonly<{
     authorizedPubkey: PublicKey;
     epochOfLastAuthorizedSwitch: number;
     targetEpoch: number;
-  };
-  export type BlockTimestamp = {
+  }>;
+  export type BlockTimestamp = Readonly<{
     slot: number;
-    timetamp: number;
-  };
+    timestamp: number;
+  }>;
   /**
    * VoteAccount class
    */

package/lib/index.esm.js

@@ -46,32 +46,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;
 }
 
@@ -1284,7 +1290,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;
@@ -1463,6 +1469,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(", ") + ")";
         }
@@ -1596,7 +1636,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);
 ///////////////////////////////
@@ -1693,7 +1733,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) {
@@ -2031,10 +2071,10 @@ const BPF_LOADER_DEPRECATED_PROGRAM_ID = new PublicKey('BPFLoader111111111111111
 const publicKey = (property = 'publicKey') => {
   return BufferLayout.blob(32, property);
 };
+
 /**
  * Layout for a Rust String type
  */
-
 const rustString = (property = 'string') => {
   const rsl = BufferLayout.struct([BufferLayout.u32('length'), BufferLayout.u32('lengthPadding'), BufferLayout.blob(BufferLayout.offset(BufferLayout.u32(), -8), 'chars')], property);
 
@@ -2042,24 +2082,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, offset) => {
+  rslShim.encode = (str, b, offset) => {
     const data = {
       chars: Buffer.from(str, 'utf8')
     };
-    return _encode(data, buffer, offset);
+    return _encode(data, b, offset);
   };
 
-  rsl.alloc = str => {
+  rslShim.alloc = str => {
     return BufferLayout.u32().span + BufferLayout.u32().span + Buffer.from(str, 'utf8').length;
   };
 
-  return rsl;
+  return rslShim;
 };
 /**
  * Layout for an Authorized object
@@ -2179,7 +2221,7 @@ class Message {
         accounts,
         programIdIndex
       } = instruction;
-      const data = bs58.decode(instruction.data);
+      const data = Array.from(bs58.decode(instruction.data));
       let keyIndicesCount = [];
       encodeLength(keyIndicesCount, accounts.length);
       let dataCount = [];
@@ -2187,7 +2229,7 @@ class Message {
       return {
         programIdIndex,
         keyIndicesCount: Buffer.from(keyIndicesCount),
-        keyIndices: Buffer.from(accounts),
+        keyIndices: accounts,
         dataLength: Buffer.from(dataCount),
         data
       };
@@ -2591,6 +2633,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.
@@ -2954,10 +3004,6 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-/**
- * @internal
- */
-
 /**
  * Populate a buffer of instruction data using an InstructionType
  * @internal
@@ -3757,11 +3803,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
@@ -3869,7 +3915,9 @@ class Loader {
         instruction: 0,
         // Load instruction
         offset,
-        bytes
+        bytes: bytes,
+        bytesLength: 0,
+        bytesLengthPadding: 0
       }, data);
       const transaction = new Transaction().add({
         keys: [{
@@ -4329,6 +4377,20 @@ const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(type({
   unitsConsumed: optional(number())
 }));
 
+/**
+ * Expected JSON RPC response for the "getBlockProduction" message
+ */
+const BlockProductionResponseStruct = jsonRpcResultAndContext(type({
+  byIdentity: record(string(), array(number())),
+  range: type({
+    firstSlot: number(),
+    lastSlot: number()
+  })
+}));
+/**
+ * A performance sample
+ */
+
 function createRpcClient(url, useHttps, httpHeaders, fetchMiddleware, disableRetryOnRateLimit) {
   let agentManager;
 
@@ -5189,6 +5251,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
    */
@@ -5474,35 +5544,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 = create(unsafeRes, jsonRpcResultAndContext(array(nullable(ParsedAccountInfoResult))));
+    const res = create(unsafeRes, jsonRpcResultAndContext(array(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
@@ -6114,6 +6181,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 = create(unsafeRes, jsonRpcResult(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 = 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.
    */
@@ -6774,12 +6889,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);
@@ -7595,16 +7704,18 @@ class Ed25519Program {
     const messageDataOffset = signatureOffset + signature.length;
     const numSignatures = 1;
     const instructionData = 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);
@@ -7675,10 +7786,10 @@ class Authorized {
   }
 
 }
+
 /**
  * Stake account lockup info
  */
-
 class Lockup {
   /** Unix timestamp of lockup expiration */
 
@@ -7703,10 +7814,6 @@ class Lockup {
 
 
 }
-/**
- * Create stake account transaction params
- */
-
 Lockup.default = new Lockup(0, 0, PublicKey.default);
 
 /**
@@ -8734,8 +8841,8 @@ class VoteAccount {
 }
 
 function parseAuthorizedVoter({
-  epoch,
-  authorizedVoter
+  authorizedVoter,
+  epoch
 }) {
   return {
     epoch,
@@ -8764,7 +8871,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)];
 }
 
 /**