@solana/rpc-graphql 2.0.0-experimental.eb14acd → 2.0.0-experimental.eb951b0

package/dist/index.node.cjs

@@ -286,23 +286,6 @@ function createAccountLoader(rpc, config) {
     loadMany: async (args) => loader.loadMany(args)
   };
 }
-function applyDefaultArgs({
-  slot,
-  commitment,
-  encoding = "jsonParsed",
-  maxSupportedTransactionVersion = 0,
-  rewards,
-  transactionDetails = "full"
-}) {
-  return {
-    commitment,
-    encoding,
-    maxSupportedTransactionVersion,
-    rewards,
-    slot,
-    transactionDetails
-  };
-}
 async function loadBlock(rpc, { slot, ...config }) {
   return await rpc.getBlock(
     slot,
@@ -312,13 +295,52 @@ async function loadBlock(rpc, { slot, ...config }) {
 }
 function createBlockBatchLoadFn(rpc) {
   const resolveBlockUsingRpc = loadBlock.bind(null, rpc);
-  return async (blockQueryArgs) => Promise.all(blockQueryArgs.map(async (args) => resolveBlockUsingRpc(applyDefaultArgs(args))));
+  return async (blockQueryArgs) => {
+    const blocksToFetch = {};
+    try {
+      return Promise.all(
+        blockQueryArgs.map(
+          ({ slot, ...args }) => new Promise((resolve, reject) => {
+            const blockRecords = blocksToFetch[slot.toString()] ||= [];
+            if (!args.commitment) {
+              args.commitment = "confirmed";
+            }
+            blockRecords.push({ args, promiseCallback: { reject, resolve } });
+          })
+        )
+      );
+    } finally {
+      const blockFetchesByArgsHash = buildCoalescedFetchesByArgsHash(blocksToFetch, {
+        criteria: (args) => args.encoding === void 0 && args.transactionDetails !== "signatures",
+        defaults: (args) => ({
+          ...args,
+          transactionDetails: "none"
+        }),
+        hashOmit: ["encoding", "transactionDetails"]
+      });
+      Object.values(blockFetchesByArgsHash).map(({ args, fetches: blockCallbacks }) => {
+        return Object.entries(blockCallbacks).map(([slot, { callbacks }]) => {
+          return Array.from({ length: 1 }, async () => {
+            try {
+              const result = await resolveBlockUsingRpc({
+                slot: BigInt(slot),
+                ...args
+              });
+              callbacks.forEach((c) => c.resolve(result));
+            } catch (e) {
+              callbacks.forEach((c) => c.reject(e));
+            }
+          });
+        });
+      });
+    }
+  };
 }
 function createBlockLoader(rpc) {
   const loader = new DataLoader__default.default(createBlockBatchLoadFn(rpc), { cacheKeyFn });
   return {
-    load: async (args) => loader.load(applyDefaultArgs(args)),
-    loadMany: async (args) => loader.loadMany(args.map(applyDefaultArgs))
+    load: async (args) => loader.load({ ...args, maxSupportedTransactionVersion: 0 }),
+    loadMany: async (args) => loader.loadMany(args.map((a) => ({ ...a, maxSupportedTransactionVersion: 0 })))
   };
 }
 async function loadProgramAccounts(rpc, { programAddress, ...config }) {
@@ -333,18 +355,23 @@ function createProgramAccountsBatchLoadFn(rpc, config) {
   return async (accountQueryArgs) => {
     const programAccountsToFetch = {};
     try {
-      return Promise.all(accountQueryArgs.map(
-        ({ programAddress, ...args }) => new Promise((resolve, reject) => {
-          const accountRecords = programAccountsToFetch[programAddress] ||= [];
-          if (!args.commitment) {
-            args.commitment = "confirmed";
-          }
-          accountRecords.push({ args, promiseCallback: { reject, resolve } });
-        })
-      ));
+      return Promise.all(
+        accountQueryArgs.map(
+          ({ programAddress, ...args }) => new Promise((resolve, reject) => {
+            const accountRecords = programAccountsToFetch[programAddress] ||= [];
+            if (!args.commitment) {
+              args.commitment = "confirmed";
+            }
+            accountRecords.push({ args, promiseCallback: { reject, resolve } });
+          })
+        )
+      );
     } finally {
       const { maxDataSliceByteRange } = config;
-      const programAccountsFetchesByArgsHash = buildCoalescedFetchesByArgsHashWithDataSlice(programAccountsToFetch, maxDataSliceByteRange);
+      const programAccountsFetchesByArgsHash = buildCoalescedFetchesByArgsHashWithDataSlice(
+        programAccountsToFetch,
+        maxDataSliceByteRange
+      );
       Object.values(programAccountsFetchesByArgsHash).map(({ args, fetches: programAddressCallbacks }) => {
         return Object.entries(programAddressCallbacks).map(([programAddress, { callbacks }]) => {
           return Array.from({ length: 1 }, async () => {
@@ -386,15 +413,17 @@ function createTransactionBatchLoadFn(rpc) {
   return async (transactionQueryArgs) => {
     const transactionsToFetch = {};
     try {
-      return Promise.all(transactionQueryArgs.map(
-        ({ signature, ...args }) => new Promise((resolve, reject) => {
-          const transactionRecords = transactionsToFetch[signature] ||= [];
-          if (!args.commitment) {
-            args.commitment = "confirmed";
-          }
-          transactionRecords.push({ args, promiseCallback: { reject, resolve } });
-        })
-      ));
+      return Promise.all(
+        transactionQueryArgs.map(
+          ({ signature, ...args }) => new Promise((resolve, reject) => {
+            const transactionRecords = transactionsToFetch[signature] ||= [];
+            if (!args.commitment) {
+              args.commitment = "confirmed";
+            }
+            transactionRecords.push({ args, promiseCallback: { reject, resolve } });
+          })
+        )
+      );
     } finally {
       const transactionFetchesByArgsHash = buildCoalescedFetchesByArgsHash(transactionsToFetch, {
         criteria: (args) => args.encoding === void 0,
@@ -559,11 +588,6 @@ function buildAccountLoaderArgSetFromResolveInfo(args, info) {
   return buildAccountArgSetWithVisitor(args, info);
 }
 
-// src/resolvers/resolve-info/program-accounts.ts
-function buildProgramAccountsLoaderArgSetFromResolveInfo(args, info) {
-  return buildAccountArgSetWithVisitor(args, info);
-}
-
 // src/resolvers/resolve-info/transaction.ts
 function findArgumentNodeByName2(argumentNodes, name) {
   return argumentNodes.find((argumentNode) => argumentNode.name.value === name);
@@ -586,7 +610,7 @@ function parseTransactionEncodingArgument(argumentNodes, variableValues) {
     return void 0;
   }
 }
-function buildTransactionLoaderArgSetFromResolveInfo(args, info) {
+function buildTransactionArgSetWithVisitor(args, info) {
   const argSet = [args];
   function buildArgSetWithVisitor(root) {
     injectableRootVisitor(info, root, {
@@ -615,6 +639,38 @@ function buildTransactionLoaderArgSetFromResolveInfo(args, info) {
   buildArgSetWithVisitor(null);
   return argSet;
 }
+function buildTransactionLoaderArgSetFromResolveInfo(args, info) {
+  return buildTransactionArgSetWithVisitor(args, info);
+}
+
+// src/resolvers/resolve-info/block.ts
+function buildBlockLoaderArgSetFromResolveInfo(args, info) {
+  const argSet = [args];
+  function buildArgSetWithVisitor(root) {
+    injectableRootVisitor(info, root, {
+      fieldNodeOperation(info2, node) {
+        if (node.name.value === "signatures") {
+          argSet.push({ ...args, transactionDetails: "signatures" });
+        } else if (node.name.value === "transactions") {
+          argSet.push(...buildTransactionArgSetWithVisitor({ ...args, transactionDetails: "full" }, info2));
+        }
+      },
+      fragmentSpreadNodeOperation(_info, fragment) {
+        buildArgSetWithVisitor(fragment);
+      },
+      inlineFragmentNodeOperation(_info, _node) {
+        return;
+      }
+    });
+  }
+  buildArgSetWithVisitor(null);
+  return argSet;
+}
+
+// src/resolvers/resolve-info/program-accounts.ts
+function buildProgramAccountsLoaderArgSetFromResolveInfo(args, info) {
+  return buildAccountArgSetWithVisitor(args, info);
+}
 
 // src/resolvers/account.ts
 var resolveAccountData = () => {
@@ -766,105 +822,208 @@ var accountResolvers = {
   }
 };
 
-// src/resolvers/block.ts
-function transformParsedInstruction(parsedInstruction) {
-  if ("parsed" in parsedInstruction) {
-    if (typeof parsedInstruction.parsed === "string" && parsedInstruction.program === "spl-memo") {
-      const { parsed: memo, program: programName2, programId: programId2 } = parsedInstruction;
-      const instructionType2 = "memo";
-      return { instructionType: instructionType2, memo, programId: programId2, programName: programName2 };
-    }
-    const {
-      parsed: { info: data, type: instructionType },
-      program: programName,
-      programId
-    } = parsedInstruction;
-    return { instructionType, programId, programName, ...data };
-  } else {
-    return parsedInstruction;
-  }
-}
-function transformParsedTransaction(parsedTransaction) {
-  const transactionData = parsedTransaction.transaction;
-  const transactionMeta = parsedTransaction.meta;
-  transactionData.message.instructions = transactionData.message.instructions.map(transformParsedInstruction);
-  transactionMeta.innerInstructions = transactionMeta.innerInstructions.map((innerInstruction) => {
-    innerInstruction.instructions = innerInstruction.instructions.map(transformParsedInstruction);
-    return innerInstruction;
+// src/resolvers/transaction.ts
+function mapJsonParsedInstructions(instructions) {
+  return instructions.map((instruction) => {
+    if ("parsed" in instruction) {
+      if (typeof instruction.parsed === "string" && instruction.program === "spl-memo") {
+        const { parsed: memo, program: programName2, programId: programId2 } = instruction;
+        const instructionType2 = "memo";
+        const jsonParsedConfigs2 = {
+          instructionType: instructionType2,
+          programId: programId2,
+          programName: programName2
+        };
+        return { jsonParsedConfigs: jsonParsedConfigs2, memo, programId: programId2 };
+      }
+      const {
+        parsed: { info: data, type: instructionType },
+        program: programName,
+        programId
+      } = instruction;
+      const jsonParsedConfigs = {
+        instructionType,
+        programId,
+        programName
+      };
+      return { jsonParsedConfigs, ...data, programId };
+    } else {
+      return instruction;
+    }
   });
-  return [transactionData, transactionMeta];
 }
-function transformLoadedTransaction({
-  encoding = "jsonParsed",
-  transaction
-}) {
-  const [transactionData, transactionMeta] = Array.isArray(transaction.transaction) ? (
-    // The requested encoding is base58 or base64.
-    [transaction.transaction[0], transaction.meta]
-  ) : (
-    // The transaction was either partially parsed or
-    // fully JSON-parsed, which will be sorted later.
-    transformParsedTransaction(transaction)
-  );
-  transaction.data = transactionData;
-  transaction.encoding = encoding;
-  transaction.meta = transactionMeta;
-  return transaction;
+function mapJsonParsedInnerInstructions(innerInstructions) {
+  return innerInstructions.map(({ index, instructions }) => ({
+    index,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    instructions: mapJsonParsedInstructions(instructions)
+  }));
 }
-function transformLoadedBlock({
-  block,
-  encoding = "jsonParsed",
-  transactionDetails = "full"
-}) {
-  const transformedBlock = block;
-  if (typeof block === "object" && "transactions" in block) {
-    transformedBlock.transactions = block.transactions.map((transaction) => {
-      if (transactionDetails === "accounts") {
-        return {
-          data: transaction.transaction,
-          meta: transaction.meta,
-          version: transaction.version
-        };
-      } else {
-        return transformLoadedTransaction({ encoding, transaction });
+var resolveTransactionData = () => {
+  return (parent, args) => {
+    return parent === null ? null : parent.encodedData ? parent.encodedData[cacheKeyFn(args)] : null;
+  };
+};
+function resolveTransaction(fieldName) {
+  return async (parent, args, context, info) => {
+    const signature = fieldName ? parent[fieldName] : args.signature;
+    if (signature) {
+      if (onlyFieldsRequested(["signature"], info)) {
+        return { signature };
       }
-    });
-  }
-  block.encoding = encoding;
-  block.transactionDetails = transactionDetails;
-  return block;
+      const argsSet = buildTransactionLoaderArgSetFromResolveInfo({ ...args, signature }, info);
+      const loadedTransactions = await context.loaders.transaction.loadMany(argsSet);
+      let result = {
+        encodedData: {},
+        signature
+      };
+      loadedTransactions.forEach((loadedTransaction, i) => {
+        if (loadedTransaction instanceof Error) {
+          console.error(loadedTransaction);
+          return;
+        }
+        if (loadedTransaction === null) {
+          return;
+        }
+        if (!result.slot) {
+          result = {
+            ...result,
+            ...loadedTransaction
+          };
+        }
+        const { transaction: data } = loadedTransaction;
+        const { encoding } = argsSet[i];
+        if (encoding && result.encodedData) {
+          if (Array.isArray(data)) {
+            result.encodedData[cacheKeyFn({
+              encoding
+            })] = data[0];
+          } else if (typeof data === "object") {
+            const jsonParsedData = data;
+            jsonParsedData.message.instructions = mapJsonParsedInstructions(
+              jsonParsedData.message.instructions
+            );
+            const loadedInnerInstructions = loadedTransaction.meta?.innerInstructions;
+            if (loadedInnerInstructions) {
+              const innerInstructions = mapJsonParsedInnerInstructions(loadedInnerInstructions);
+              const jsonParsedMeta = {
+                ...loadedTransaction.meta,
+                innerInstructions
+              };
+              result = {
+                ...result,
+                ...jsonParsedData,
+                meta: jsonParsedMeta
+              };
+            } else {
+              result = {
+                ...result,
+                ...jsonParsedData
+              };
+            }
+          }
+        }
+      });
+      return result;
+    }
+    return null;
+  };
 }
+var transactionResolvers = {
+  Transaction: {
+    data: resolveTransactionData()
+  }
+};
+
+// src/resolvers/block.ts
 var resolveBlock = (fieldName) => {
   return async (parent, args, context, info) => {
     const slot = fieldName ? parent[fieldName] : args.slot;
-    if (!slot) {
-      return null;
-    }
-    if (onlyFieldsRequested(["slot"], info)) {
-      return { slot };
-    }
-    const block = await context.loaders.block.load({ ...args, slot });
-    if (block === null) {
-      return null;
+    if (slot) {
+      if (onlyFieldsRequested(["slot"], info)) {
+        return { slot };
+      }
+      const argsSet = buildBlockLoaderArgSetFromResolveInfo({ ...args, slot }, info);
+      const loadedBlocks = await context.loaders.block.loadMany(argsSet);
+      let result = {
+        slot
+      };
+      loadedBlocks.forEach((loadedBlock, i) => {
+        if (loadedBlock instanceof Error) {
+          console.error(loadedBlock);
+          return;
+        }
+        if (loadedBlock === null) {
+          return;
+        }
+        if (!result.blockhash) {
+          result = {
+            ...result,
+            ...loadedBlock
+          };
+        }
+        if (!result.signatures && loadedBlock.signatures) {
+          result = {
+            ...result,
+            // @ts-expect-error FIX ME: https://github.com/solana-labs/solana-web3.js/pull/2052
+            signatures: loadedBlock.signatures
+          };
+        }
+        if (!result.transactionResults && loadedBlock.transactions) {
+          result.transactionResults = Array.from({ length: loadedBlock.transactions.length }, (_, i2) => ({
+            [i2]: { encodedData: {} }
+          }));
+        }
+        const { transactions } = loadedBlock;
+        const { encoding } = argsSet[i];
+        if (encoding) {
+          transactions.forEach((loadedTransaction, j) => {
+            const { transaction: data } = loadedTransaction;
+            if (result.transactionResults) {
+              const thisTransactionResult = result.transactionResults[j] ||= {
+                encodedData: {}
+              };
+              if (Array.isArray(data)) {
+                const thisEncodedData = thisTransactionResult.encodedData ||= {};
+                thisEncodedData[cacheKeyFn({
+                  encoding
+                })] = data[0];
+              } else if (typeof data === "object") {
+                const jsonParsedData = data;
+                jsonParsedData.message.instructions = mapJsonParsedInstructions(
+                  jsonParsedData.message.instructions
+                );
+                const loadedInnerInstructions = loadedTransaction.meta?.innerInstructions;
+                if (loadedInnerInstructions) {
+                  const innerInstructions = mapJsonParsedInnerInstructions(loadedInnerInstructions);
+                  const jsonParsedMeta = {
+                    ...loadedTransaction.meta,
+                    innerInstructions
+                  };
+                  result.transactionResults[j] = {
+                    ...thisTransactionResult,
+                    ...jsonParsedData,
+                    meta: jsonParsedMeta
+                  };
+                } else {
+                  result.transactionResults[j] = {
+                    ...thisTransactionResult,
+                    ...jsonParsedData
+                  };
+                }
+              }
+            }
+          });
+        }
+      });
+      return result;
     }
-    const { encoding, transactionDetails } = args;
-    return transformLoadedBlock({ block, encoding, transactionDetails });
+    return null;
   };
 };
 var blockResolvers = {
   Block: {
-    __resolveType(block) {
-      switch (block.transactionDetails) {
-        case "accounts":
-          return "BlockWithAccounts";
-        case "none":
-          return "BlockWithNone";
-        case "signatures":
-          return "BlockWithSignatures";
-        default:
-          return "BlockWithFull";
-      }
-    }
+    transactions: (parent) => parent?.transactionResults ? Object.values(parent.transactionResults) : null
   }
 };
 
@@ -1682,119 +1841,6 @@ function resolveProgramAccounts(fieldName) {
   };
 }
 
-// src/resolvers/transaction.ts
-function mapJsonParsedInstructions(instructions) {
-  return instructions.map((instruction) => {
-    if ("parsed" in instruction) {
-      if (typeof instruction.parsed === "string" && instruction.program === "spl-memo") {
-        const { parsed: memo, program: programName2, programId: programId2 } = instruction;
-        const instructionType2 = "memo";
-        const jsonParsedConfigs2 = {
-          instructionType: instructionType2,
-          programId: programId2,
-          programName: programName2
-        };
-        return { jsonParsedConfigs: jsonParsedConfigs2, memo, programId: programId2 };
-      }
-      const {
-        parsed: { info: data, type: instructionType },
-        program: programName,
-        programId
-      } = instruction;
-      const jsonParsedConfigs = {
-        instructionType,
-        programId,
-        programName
-      };
-      return { jsonParsedConfigs, ...data, programId };
-    } else {
-      return instruction;
-    }
-  });
-}
-function mapJsonParsedInnerInstructions(innerInstructions) {
-  return innerInstructions.map(({ index, instructions }) => ({
-    index,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    instructions: mapJsonParsedInstructions(instructions)
-  }));
-}
-var resolveTransactionData = () => {
-  return (parent, args) => {
-    return parent === null ? null : parent.encodedData ? parent.encodedData[cacheKeyFn(args)] : null;
-  };
-};
-function resolveTransaction(fieldName) {
-  return async (parent, args, context, info) => {
-    const signature = fieldName ? parent[fieldName] : args.signature;
-    if (signature) {
-      if (onlyFieldsRequested(["signature"], info)) {
-        return { signature };
-      }
-      const argsSet = buildTransactionLoaderArgSetFromResolveInfo({ ...args, signature }, info);
-      const loadedTransactions = await context.loaders.transaction.loadMany(argsSet);
-      let result = {
-        encodedData: {},
-        signature
-      };
-      loadedTransactions.forEach((loadedTransaction, i) => {
-        if (loadedTransaction instanceof Error) {
-          console.error(loadedTransaction);
-          return;
-        }
-        if (loadedTransaction === null) {
-          return;
-        }
-        if (!result.slot) {
-          result = {
-            ...result,
-            ...loadedTransaction
-          };
-        }
-        const { transaction: data } = loadedTransaction;
-        const { encoding } = argsSet[i];
-        if (encoding && result.encodedData) {
-          if (Array.isArray(data)) {
-            result.encodedData[cacheKeyFn({
-              encoding
-            })] = data[0];
-          } else if (typeof data === "object") {
-            const jsonParsedData = data;
-            jsonParsedData.message.instructions = mapJsonParsedInstructions(
-              jsonParsedData.message.instructions
-            );
-            const loadedInnerInstructions = loadedTransaction.meta?.innerInstructions;
-            if (loadedInnerInstructions) {
-              const innerInstructions = mapJsonParsedInnerInstructions(loadedInnerInstructions);
-              const jsonParsedMeta = {
-                ...loadedTransaction.meta,
-                innerInstructions
-              };
-              result = {
-                ...result,
-                ...jsonParsedData,
-                meta: jsonParsedMeta
-              };
-            } else {
-              result = {
-                ...result,
-                ...jsonParsedData
-              };
-            }
-          }
-        }
-      });
-      return result;
-    }
-    return null;
-  };
-}
-var transactionResolvers = {
-  Transaction: {
-    data: resolveTransactionData()
-  }
-};
-
 // src/resolvers/root.ts
 var rootResolvers = {
   Query: {
@@ -1820,7 +1866,7 @@ var stringScalarAlias = {
 };
 var bigIntScalarAlias = {
   __parseLiteral(ast) {
-    if (ast.kind === graphql.Kind.STRING) {
+    if (ast.kind === graphql.Kind.STRING || ast.kind === graphql.Kind.INT || ast.kind === graphql.Kind.FLOAT) {
       return BigInt(ast.value);
     }
     return null;
@@ -1843,12 +1889,6 @@ var typeTypeResolvers = {
   Base64EncodedBytes: stringScalarAlias,
   Base64ZstdEncodedBytes: stringScalarAlias,
   BigInt: bigIntScalarAlias,
-  BlockTransactionDetails: {
-    ACCOUNTS: "accounts",
-    FULL: "full",
-    NONE: "none",
-    SIGNATURES: "signatures"
-  },
   Commitment: {
     CONFIRMED: "confirmed",
     FINALIZED: "finalized",
@@ -1866,12 +1906,7 @@ var typeTypeResolvers = {
   },
   TransactionEncoding: {
     BASE_58: "base58",
-    BASE_64: "base64",
-    PARSED: "jsonParsed"
-  },
-  TransactionVersion: {
-    LEGACY: "legacy",
-    ZERO: 0
+    BASE_64: "base64"
   }
 };
 
@@ -2075,93 +2110,18 @@ var accountTypeDefs = (
 var blockTypeDefs = (
   /* GraphQL */
   `
-    type TransactionMetaForAccounts {
-        err: String
-        fee: BigInt
-        postBalances: [BigInt]
-        postTokenBalances: [TokenBalance]
-        preBalances: [BigInt]
-        preTokenBalances: [TokenBalance]
-        status: TransactionStatus
-    }
-
-    type TransactionDataForAccounts {
-        accountKeys: [Address]
-        signatures: [String]
-    }
-
-    type BlockTransactionAccounts {
-        meta: TransactionMetaForAccounts
-        data: TransactionDataForAccounts
-        version: String
-    }
-
-    """
-    Block interface
-    """
-    interface Block {
-        blockhash: String
-        blockHeight: BigInt
-        blockTime: BigInt
-        parentSlot: BigInt
-        previousBlockhash: String
-        rewards: [Reward]
-        transactionDetails: String
-    }
-
-    """
-    A block with account transaction details
-    """
-    type BlockWithAccounts implements Block {
-        blockhash: String
-        blockHeight: BigInt
-        blockTime: BigInt
-        parentSlot: BigInt
-        previousBlockhash: String
-        rewards: [Reward]
-        transactions: [BlockTransactionAccounts]
-        transactionDetails: String
-    }
-
     """
-    A block with full transaction details
+    A Solana block
     """
-    type BlockWithFull implements Block {
+    type Block {
         blockhash: String
         blockHeight: BigInt
         blockTime: BigInt
-        parentSlot: BigInt
+        parentSlot: Slot
         previousBlockhash: String
         rewards: [Reward]
+        signatures: [Signature]
         transactions: [Transaction]
-        transactionDetails: String
-    }
-
-    """
-    A block with no transaction details
-    """
-    type BlockWithNone implements Block {
-        blockhash: String
-        blockHeight: BigInt
-        blockTime: BigInt
-        parentSlot: BigInt
-        previousBlockhash: String
-        rewards: [Reward]
-        transactionDetails: String
-    }
-
-    """
-    A block with signature transaction details
-    """
-    type BlockWithSignatures implements Block {
-        blockhash: String
-        blockHeight: BigInt
-        blockTime: BigInt
-        parentSlot: BigInt
-        previousBlockhash: String
-        rewards: [Reward]
-        signatures: [String]
-        transactionDetails: String
     }
 `
 );
@@ -3220,12 +3180,7 @@ var rootTypeDefs = (
   `
     type Query {
         account(address: Address!, commitment: Commitment, minContextSlot: Slot): Account
-        block(
-            slot: Slot!
-            commitment: Commitment
-            encoding: TransactionEncoding
-            transactionDetails: BlockTransactionDetails
-        ): Block
+        block(slot: Slot!, commitment: CommitmentWithoutProcessed): Block
         programAccounts(
             programAddress: Address!
             commitment: Commitment
@@ -3341,13 +3296,6 @@ var typeTypeDefs = (
 
     scalar BigInt
 
-    enum BlockTransactionDetails {
-        ACCOUNTS
-        FULL
-        NONE
-        SIGNATURES
-    }
-
     enum Commitment {
         CONFIRMED
         FINALIZED
@@ -3406,12 +3354,6 @@ var typeTypeDefs = (
     enum TransactionEncoding {
         BASE_58
         BASE_64
-        PARSED
-    }
-
-    enum TransactionVersion {
-        LEGACY
-        ZERO
     }
 `
 );