@solana/web3.js 1.30.1 → 1.32.1

package/src/connection.ts

@@ -99,6 +99,8 @@ export type SendOptions = {
   skipPreflight?: boolean;
   /** preflight commitment level */
   preflightCommitment?: Commitment;
+  /** Maximum number of times for the RPC node to retry sending the transaction to the leader. */
+  maxRetries?: number;
 };
 
 /**
@@ -111,6 +113,8 @@ export type ConfirmOptions = {
   commitment?: Commitment;
   /** preflight commitment level */
   preflightCommitment?: Commitment;
+  /** Maximum number of times for the RPC node to retry sending the transaction to the leader. */
+  maxRetries?: number;
 };
 
 /**
@@ -498,13 +502,21 @@ export type ParsedInnerInstruction = {
 export type TokenBalance = {
   accountIndex: number;
   mint: string;
+  owner?: string;
   uiTokenAmount: TokenAmount;
 };
 
 /**
  * Metadata for a parsed confirmed transaction on the ledger
+ *
+ * @deprecated Deprecated since Solana v1.8.0. Please use {@link ParsedTransactionMeta} instead.
  */
-export type ParsedConfirmedTransactionMeta = {
+export type ParsedConfirmedTransactionMeta = ParsedTransactionMeta;
+
+/**
+ * Metadata for a parsed transaction on the ledger
+ */
+export type ParsedTransactionMeta = {
   /** The fee charged for processing the transaction */
   fee: number;
   /** An array of cross program invoked parsed instructions */
@@ -643,14 +655,21 @@ export type ParsedTransaction = {
 
 /**
  * A parsed and confirmed transaction on the ledger
+ *
+ * @deprecated Deprecated since Solana v1.8.0. Please use {@link ParsedTransactionWithMeta} instead.
  */
-export type ParsedConfirmedTransaction = {
+export type ParsedConfirmedTransaction = ParsedTransactionWithMeta;
+
+/**
+ * A parsed transaction on the ledger with meta
+ */
+export type ParsedTransactionWithMeta = {
   /** The slot during which the transaction was processed */
   slot: number;
   /** The details of the transaction */
   transaction: ParsedTransaction;
   /** Metadata produced from the transaction */
-  meta: ParsedConfirmedTransactionMeta | null;
+  meta: ParsedTransactionMeta | null;
   /** The unix timestamp of when the transaction was processed */
   blockTime?: number | null;
 };
@@ -719,9 +738,9 @@ export type ConfirmedBlock = {
 };
 
 /**
- * A ConfirmedBlock on the ledger with signatures only
+ * A Block on the ledger with signatures only
  */
-export type ConfirmedBlockSignatures = {
+export type BlockSignatures = {
   /** Blockhash of this block */
   blockhash: Blockhash;
   /** Blockhash of this block's parent */
@@ -760,19 +779,24 @@ function createRpcClient(
     agentManager = new AgentManager(useHttps);
   }
 
-  let fetchWithMiddleware: (url: string, options: any) => Promise<Response>;
+  let fetchWithMiddleware:
+    | ((url: string, options: any) => Promise<Response>)
+    | undefined;
 
   if (fetchMiddleware) {
-    fetchWithMiddleware = (url: string, options: any) => {
-      return new Promise<Response>((resolve, reject) => {
-        fetchMiddleware(url, options, async (url: string, options: any) => {
+    fetchWithMiddleware = async (url: string, options: any) => {
+      const modifiedFetchArgs = await new Promise<[string, any]>(
+        (resolve, reject) => {
           try {
-            resolve(await fetch(url, options));
+            fetchMiddleware(url, options, (modifiedUrl, modifiedOptions) =>
+              resolve([modifiedUrl, modifiedOptions]),
+            );
           } catch (error) {
             reject(error);
           }
-        });
-      });
+        },
+      );
+      return await fetch(...modifiedFetchArgs);
     };
   }
 
@@ -1432,6 +1456,7 @@ const ParsedConfirmedTransactionResult = pick({
 const TokenBalanceResult = pick({
   accountIndex: number(),
   mint: string(),
+  owner: optional(string()),
   uiTokenAmount: TokenAmountResult,
 });
 
@@ -1487,8 +1512,41 @@ const ParsedConfirmedTransactionMetaResult = pick({
   postTokenBalances: optional(nullable(array(TokenBalanceResult))),
 });
 
+/**
+ * Expected JSON RPC response for the "getBlock" message
+ */
+const GetBlockRpcResult = jsonRpcResult(
+  nullable(
+    pick({
+      blockhash: string(),
+      previousBlockhash: string(),
+      parentSlot: number(),
+      transactions: array(
+        pick({
+          transaction: ConfirmedTransactionResult,
+          meta: nullable(ConfirmedTransactionMetaResult),
+        }),
+      ),
+      rewards: optional(
+        array(
+          pick({
+            pubkey: string(),
+            lamports: number(),
+            postBalance: nullable(number()),
+            rewardType: nullable(string()),
+          }),
+        ),
+      ),
+      blockTime: nullable(number()),
+      blockHeight: nullable(number()),
+    }),
+  ),
+);
+
 /**
  * Expected JSON RPC response for the "getConfirmedBlock" message
+ *
+ * @deprecated Deprecated since Solana v1.8.0. Please use {@link GetBlockRpcResult} instead.
  */
 const GetConfirmedBlockRpcResult = jsonRpcResult(
   nullable(
@@ -1518,9 +1576,9 @@ const GetConfirmedBlockRpcResult = jsonRpcResult(
 );
 
 /**
- * Expected JSON RPC response for the "getConfirmedBlockSignatures" message
+ * Expected JSON RPC response for the "getBlock" message
  */
-const GetConfirmedBlockSignaturesRpcResult = jsonRpcResult(
+const GetBlockSignaturesRpcResult = jsonRpcResult(
   nullable(
     pick({
       blockhash: string(),
@@ -1533,9 +1591,9 @@ const GetConfirmedBlockSignaturesRpcResult = jsonRpcResult(
 );
 
 /**
- * Expected JSON RPC response for the "getConfirmedTransaction" message
+ * Expected JSON RPC response for the "getTransaction" message
  */
-const GetConfirmedTransactionRpcResult = jsonRpcResult(
+const GetTransactionRpcResult = jsonRpcResult(
   nullable(
     pick({
       slot: number(),
@@ -1547,9 +1605,9 @@ const GetConfirmedTransactionRpcResult = jsonRpcResult(
 );
 
 /**
- * Expected JSON RPC response for the "getConfirmedTransaction" message
+ * Expected parsed JSON RPC response for the "getTransaction" message
  */
-const GetParsedConfirmedTransactionRpcResult = jsonRpcResult(
+const GetParsedTransactionRpcResult = jsonRpcResult(
   nullable(
     pick({
       slot: number(),
@@ -1562,6 +1620,8 @@ const GetParsedConfirmedTransactionRpcResult = jsonRpcResult(
 
 /**
  * Expected JSON RPC response for the "getRecentBlockhash" message
+ *
+ * @deprecated Deprecated since Solana v1.8.0. Please use {@link GetLatestBlockhashRpcResult} instead.
  */
 const GetRecentBlockhashAndContextRpcResult = jsonRpcResultAndContext(
   pick({
@@ -1572,6 +1632,16 @@ const GetRecentBlockhashAndContextRpcResult = jsonRpcResultAndContext(
   }),
 );
 
+/**
+ * Expected JSON RPC response for the "getLatestBlockhash" message
+ */
+const GetLatestBlockhashRpcResult = jsonRpcResultAndContext(
+  pick({
+    blockhash: string(),
+    lastValidBlockHeight: number(),
+  }),
+);
+
 const PerfSampleResult = pick({
   slot: number(),
   numTransactions: number(),
@@ -1706,6 +1776,16 @@ export type GetParsedProgramAccountsConfig = {
   filters?: GetProgramAccountsFilter[];
 };
 
+/**
+ * Configuration object for getMultipleAccounts
+ */
+export type GetMultipleAccountsConfig = {
+  /** Optional commitment level */
+  commitment?: Commitment;
+  /** Optional encoding for account data (default base64) */
+  encoding?: 'base64' | 'jsonParsed';
+};
+
 /**
  * Information describing an account
  */
@@ -1718,7 +1798,7 @@ export type AccountInfo<T> = {
   lamports: number;
   /** Optional data assigned to the account */
   data: T;
-  /** Optional rent epoch infor for account */
+  /** Optional rent epoch info for account */
   rentEpoch?: number;
 };
 
@@ -1972,7 +2052,7 @@ export type HttpHeaders = {[header: string]: string};
 export type FetchMiddleware = (
   url: string,
   options: any,
-  fetch: Function,
+  fetch: (modifiedUrl: string, modifiedOptions: any) => void,
 ) => void;
 
 /**
@@ -2474,14 +2554,27 @@ export class Connection {
    */
   async getMultipleAccountsInfo(
     publicKeys: PublicKey[],
-    commitment?: Commitment,
-  ): Promise<(AccountInfo<Buffer> | null)[]> {
+    configOrCommitment?: GetMultipleAccountsConfig | Commitment,
+  ): Promise<(AccountInfo<Buffer | ParsedAccountData> | null)[]> {
     const keys = publicKeys.map(key => key.toBase58());
-    const args = this._buildArgs([keys], commitment, 'base64');
+
+    let commitment;
+    let encoding: 'base64' | 'jsonParsed' = '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 unsafeRes = await this._rpcRequest('getMultipleAccounts', args);
     const res = create(
       unsafeRes,
-      jsonRpcResultAndContext(array(nullable(AccountInfoResult))),
+      jsonRpcResultAndContext(array(nullable(ParsedAccountInfoResult))),
     );
     if ('error' in res) {
       throw new Error(
@@ -2932,6 +3025,8 @@ export class Connection {
   /**
    * Fetch a recent blockhash from the cluster, return with context
    * @return {Promise<RpcResponseAndContext<{blockhash: Blockhash, feeCalculator: FeeCalculator}>>}
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getLatestBlockhash} instead.
    */
   async getRecentBlockhashAndContext(
     commitment?: Commitment,
@@ -2971,6 +3066,8 @@ export class Connection {
 
   /**
    * Fetch the fee calculator for a recent blockhash from the cluster, return with context
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getFeeForMessage} instead.
    */
   async getFeeCalculatorForBlockhash(
     blockhash: Blockhash,
@@ -2993,9 +3090,32 @@ export class Connection {
     };
   }
 
+  /**
+   * Fetch the fee for a message from the cluster, return with context
+   */
+  async getFeeForMessage(
+    message: Message,
+    commitment?: Commitment,
+  ): Promise<RpcResponseAndContext<number>> {
+    const wireMessage = message.serialize().toString('base64');
+    const args = this._buildArgs([wireMessage], commitment);
+    const unsafeRes = await this._rpcRequest('getFeeForMessage', args);
+
+    const res = create(unsafeRes, jsonRpcResultAndContext(nullable(number())));
+    if ('error' in res) {
+      throw new Error('failed to get slot: ' + res.error.message);
+    }
+    if (res.result === null) {
+      throw new Error('invalid blockhash');
+    }
+    return res.result as unknown as RpcResponseAndContext<number>;
+  }
+
   /**
    * Fetch a recent blockhash from the cluster
    * @return {Promise<{blockhash: Blockhash, feeCalculator: FeeCalculator}>}
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getLatestBlockhash} instead.
    */
   async getRecentBlockhash(
     commitment?: Commitment,
@@ -3008,6 +3128,39 @@ export class Connection {
     }
   }
 
+  /**
+   * Fetch the latest blockhash from the cluster
+   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   */
+  async getLatestBlockhash(
+    commitment?: Commitment,
+  ): Promise<{blockhash: Blockhash; lastValidBlockHeight: number}> {
+    try {
+      const res = await this.getLatestBlockhashAndContext(commitment);
+      return res.value;
+    } catch (e) {
+      throw new Error('failed to get recent blockhash: ' + e);
+    }
+  }
+
+  /**
+   * Fetch the latest blockhash from the cluster
+   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   */
+  async getLatestBlockhashAndContext(
+    commitment?: Commitment,
+  ): Promise<
+    RpcResponseAndContext<{blockhash: Blockhash; lastValidBlockHeight: number}>
+  > {
+    const args = this._buildArgs([], commitment);
+    const unsafeRes = await this._rpcRequest('getLatestBlockhash', args);
+    const res = create(unsafeRes, GetLatestBlockhashRpcResult);
+    if ('error' in res) {
+      throw new Error('failed to get latest blockhash: ' + res.error.message);
+    }
+    return res.result;
+  }
+
   /**
    * Fetch the node version
    */
@@ -3043,8 +3196,8 @@ export class Connection {
       [slot],
       opts && opts.commitment,
     );
-    const unsafeRes = await this._rpcRequest('getConfirmedBlock', args);
-    const res = create(unsafeRes, GetConfirmedBlockRpcResult);
+    const unsafeRes = await this._rpcRequest('getBlock', args);
+    const res = create(unsafeRes, GetBlockRpcResult);
 
     if ('error' in res) {
       throw new Error('failed to get confirmed block: ' + res.error.message);
@@ -3069,7 +3222,7 @@ export class Connection {
   }
 
   /**
-   * Fetch a processed transaction from the cluster.
+   * Fetch a confirmed or finalized transaction from the cluster.
    */
   async getTransaction(
     signature: string,
@@ -3079,12 +3232,10 @@ export class Connection {
       [signature],
       opts && opts.commitment,
     );
-    const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);
-    const res = create(unsafeRes, GetConfirmedTransactionRpcResult);
+    const unsafeRes = await this._rpcRequest('getTransaction', args);
+    const res = create(unsafeRes, GetTransactionRpcResult);
     if ('error' in res) {
-      throw new Error(
-        'failed to get confirmed transaction: ' + res.error.message,
-      );
+      throw new Error('failed to get transaction: ' + res.error.message);
     }
 
     const result = res.result;
@@ -3099,6 +3250,57 @@ export class Connection {
     };
   }
 
+  /**
+   * Fetch parsed transaction details for a confirmed or finalized transaction
+   */
+  async getParsedTransaction(
+    signature: TransactionSignature,
+    commitment?: Finality,
+  ): Promise<ParsedConfirmedTransaction | null> {
+    const args = this._buildArgsAtLeastConfirmed(
+      [signature],
+      commitment,
+      'jsonParsed',
+    );
+    const unsafeRes = await this._rpcRequest('getTransaction', args);
+    const res = create(unsafeRes, GetParsedTransactionRpcResult);
+    if ('error' in res) {
+      throw new Error('failed to get transaction: ' + res.error.message);
+    }
+    return res.result;
+  }
+
+  /**
+   * Fetch parsed transaction details for a batch of confirmed transactions
+   */
+  async getParsedTransactions(
+    signatures: TransactionSignature[],
+    commitment?: Finality,
+  ): Promise<(ParsedConfirmedTransaction | null)[]> {
+    const batch = signatures.map(signature => {
+      const args = this._buildArgsAtLeastConfirmed(
+        [signature],
+        commitment,
+        'jsonParsed',
+      );
+      return {
+        methodName: 'getTransaction',
+        args,
+      };
+    });
+
+    const unsafeRes = await this._rpcBatchRequest(batch);
+    const res = unsafeRes.map((unsafeRes: any) => {
+      const res = create(unsafeRes, GetParsedTransactionRpcResult);
+      if ('error' in res) {
+        throw new Error('failed to get transactions: ' + res.error.message);
+      }
+      return res.result;
+    });
+
+    return res;
+  }
+
   /**
    * Fetch a list of Transactions and transaction statuses from the cluster
    * for a confirmed block.
@@ -3109,14 +3311,36 @@ export class Connection {
     slot: number,
     commitment?: Finality,
   ): Promise<ConfirmedBlock> {
-    const result = await this.getBlock(slot, {commitment});
+    const args = this._buildArgsAtLeastConfirmed([slot], commitment);
+    const unsafeRes = await this._rpcRequest('getConfirmedBlock', args);
+    const res = create(unsafeRes, GetConfirmedBlockRpcResult);
+
+    if ('error' in res) {
+      throw new Error('failed to get confirmed block: ' + res.error.message);
+    }
+
+    const result = res.result;
     if (!result) {
       throw new Error('Confirmed block ' + slot + ' not found');
     }
 
-    return {
+    const block = {
       ...result,
       transactions: result.transactions.map(({transaction, meta}) => {
+        const message = new Message(transaction.message);
+        return {
+          meta,
+          transaction: {
+            ...transaction,
+            message,
+          },
+        };
+      }),
+    };
+
+    return {
+      ...block,
+      transactions: block.transactions.map(({transaction, meta}) => {
         return {
           meta,
           transaction: Transaction.populate(
@@ -3140,7 +3364,7 @@ export class Connection {
       endSlot !== undefined ? [startSlot, endSlot] : [startSlot],
       commitment,
     );
-    const unsafeRes = await this._rpcRequest('getConfirmedBlocks', args);
+    const unsafeRes = await this._rpcRequest('getBlocks', args);
     const res = create(unsafeRes, jsonRpcResult(array(number())));
     if ('error' in res) {
       throw new Error('failed to get blocks: ' + res.error.message);
@@ -3148,13 +3372,43 @@ export class Connection {
     return res.result;
   }
 
+  /**
+   * Fetch a list of Signatures from the cluster for a block, excluding rewards
+   */
+  async getBlockSignatures(
+    slot: number,
+    commitment?: Finality,
+  ): Promise<BlockSignatures> {
+    const args = this._buildArgsAtLeastConfirmed(
+      [slot],
+      commitment,
+      undefined,
+      {
+        transactionDetails: 'signatures',
+        rewards: false,
+      },
+    );
+    const unsafeRes = await this._rpcRequest('getBlock', args);
+    const res = create(unsafeRes, GetBlockSignaturesRpcResult);
+    if ('error' in res) {
+      throw new Error('failed to get block: ' + res.error.message);
+    }
+    const result = res.result;
+    if (!result) {
+      throw new Error('Block ' + slot + ' not found');
+    }
+    return result;
+  }
+
   /**
    * Fetch a list of Signatures from the cluster for a confirmed block, excluding rewards
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getBlockSignatures} instead.
    */
   async getConfirmedBlockSignatures(
     slot: number,
     commitment?: Finality,
-  ): Promise<ConfirmedBlockSignatures> {
+  ): Promise<BlockSignatures> {
     const args = this._buildArgsAtLeastConfirmed(
       [slot],
       commitment,
@@ -3165,7 +3419,7 @@ export class Connection {
       },
     );
     const unsafeRes = await this._rpcRequest('getConfirmedBlock', args);
-    const res = create(unsafeRes, GetConfirmedBlockSignaturesRpcResult);
+    const res = create(unsafeRes, GetBlockSignaturesRpcResult);
     if ('error' in res) {
       throw new Error('failed to get confirmed block: ' + res.error.message);
     }
@@ -3178,14 +3432,25 @@ export class Connection {
 
   /**
    * Fetch a transaction details for a confirmed transaction
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getTransaction} instead.
    */
   async getConfirmedTransaction(
     signature: TransactionSignature,
     commitment?: Finality,
   ): Promise<ConfirmedTransaction | null> {
-    const result = await this.getTransaction(signature, {commitment});
+    const args = this._buildArgsAtLeastConfirmed([signature], commitment);
+    const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);
+    const res = create(unsafeRes, GetTransactionRpcResult);
+    if ('error' in res) {
+      throw new Error('failed to get transaction: ' + res.error.message);
+    }
+
+    const result = res.result;
     if (!result) return result;
-    const {message, signatures} = result.transaction;
+
+    const message = new Message(result.transaction.message);
+    const signatures = result.transaction.signatures;
     return {
       ...result,
       transaction: Transaction.populate(message, signatures),
@@ -3194,6 +3459,8 @@ export class Connection {
 
   /**
    * Fetch parsed transaction details for a confirmed transaction
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getParsedTransaction} instead.
    */
   async getParsedConfirmedTransaction(
     signature: TransactionSignature,
@@ -3205,7 +3472,7 @@ export class Connection {
       'jsonParsed',
     );
     const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);
-    const res = create(unsafeRes, GetParsedConfirmedTransactionRpcResult);
+    const res = create(unsafeRes, GetParsedTransactionRpcResult);
     if ('error' in res) {
       throw new Error(
         'failed to get confirmed transaction: ' + res.error.message,
@@ -3216,6 +3483,8 @@ export class Connection {
 
   /**
    * Fetch parsed transaction details for a batch of confirmed transactions
+   *
+   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getParsedTransactions} instead.
    */
   async getParsedConfirmedTransactions(
     signatures: TransactionSignature[],
@@ -3235,7 +3504,7 @@ export class Connection {
 
     const unsafeRes = await this._rpcBatchRequest(batch);
     const res = unsafeRes.map((unsafeRes: any) => {
-      const res = create(unsafeRes, GetParsedConfirmedTransactionRpcResult);
+      const res = create(unsafeRes, GetParsedTransactionRpcResult);
       if ('error' in res) {
         throw new Error(
           'failed to get confirmed transactions: ' + res.error.message,
@@ -3666,6 +3935,9 @@ export class Connection {
     const preflightCommitment =
       (options && options.preflightCommitment) || this.commitment;
 
+    if (options && options.maxRetries) {
+      config.maxRetries = options.maxRetries;
+    }
     if (skipPreflight) {
       config.skipPreflight = skipPreflight;
     }

package/src/keypair.ts

@@ -1,4 +1,4 @@
-import * as nacl from 'tweetnacl';
+import nacl from 'tweetnacl';
 
 import {PublicKey} from './publickey';
 

package/src/publickey.ts

@@ -87,6 +87,10 @@ export class PublicKey extends Struct {
     return bs58.encode(this.toBytes());
   }
 
+  toJSON(): string {
+    return this.toBase58();
+  }
+
   /**
    * Return the byte array representation of the public key
    */

package/src/secp256k1-program.ts

@@ -1,7 +1,7 @@
 import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
 import secp256k1 from 'secp256k1';
-import {keccak_256} from 'js-sha3';
+import sha3 from 'js-sha3';
 
 import {PublicKey} from './publickey';
 import {TransactionInstruction} from './transaction';
@@ -86,9 +86,9 @@ export class Secp256k1Program {
     );
 
     try {
-      return Buffer.from(keccak_256.update(toBuffer(publicKey)).digest()).slice(
-        -ETHEREUM_ADDRESS_BYTES,
-      );
+      return Buffer.from(
+        sha3.keccak_256.update(toBuffer(publicKey)).digest(),
+      ).slice(-ETHEREUM_ADDRESS_BYTES);
     } catch (error) {
       throw new Error(`Error constructing Ethereum address: ${error}`);
     }
@@ -197,7 +197,7 @@ export class Secp256k1Program {
       const privateKey = toBuffer(pkey);
       const publicKey = publicKeyCreate(privateKey, false).slice(1); // throw away leading byte
       const messageHash = Buffer.from(
-        keccak_256.update(toBuffer(message)).digest(),
+        sha3.keccak_256.update(toBuffer(message)).digest(),
       );
       const {signature, recid: recoveryId} = ecdsaSign(messageHash, privateKey);