@solana/rpc-graphql 2.0.0-experimental.fb51adb → 2.0.0-experimental.fb655dd

package/dist/index.browser.js

@@ -13,6 +13,151 @@ function replacer(_, value) {
 }
 var cacheKeyFn = (obj) => stringify(obj, { replacer });
 
+// src/loaders/coalescer.ts
+var hashOmit = (args, omit) => {
+  const argsObj = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (!omit.includes(key)) {
+      argsObj[key] = value;
+    }
+  }
+  return cacheKeyFn(argsObj);
+};
+function buildCoalescedFetchesByArgsHash(toFetchMap, orphanConfig) {
+  const fetchesByArgsHash = {};
+  const orphanedFetches = {};
+  Object.entries(toFetchMap).forEach(([signature, toFetch]) => {
+    toFetch.forEach(({ args, promiseCallback }) => {
+      if (orphanConfig.criteria(args)) {
+        const toFetch2 = orphanedFetches[signature] ||= [];
+        toFetch2.push({ args, promiseCallback });
+        return;
+      }
+      const argsHash = hashOmit(args, []);
+      const transactionFetches = fetchesByArgsHash[argsHash] ||= {
+        args,
+        fetches: {}
+      };
+      const { callbacks: promiseCallbacksForSignature } = transactionFetches.fetches[signature] ||= {
+        callbacks: []
+      };
+      promiseCallbacksForSignature.push(promiseCallback);
+    });
+  });
+  Object.entries(orphanedFetches).forEach(([signature, toFetch]) => {
+    toFetch.forEach(({ args: orphanArgs, promiseCallback: orphanPromiseCallback }) => {
+      if (Object.keys(fetchesByArgsHash).length !== 0) {
+        for (const { fetches, args: args2 } of Object.values(fetchesByArgsHash)) {
+          if (hashOmit(orphanArgs, orphanConfig.hashOmit) === hashOmit(args2, orphanConfig.hashOmit)) {
+            const { callbacks: promiseCallbacksForSignature2 } = fetches[signature] ||= {
+              callbacks: []
+            };
+            promiseCallbacksForSignature2.push(orphanPromiseCallback);
+            return;
+          }
+        }
+      }
+      const args = orphanConfig.defaults(orphanArgs);
+      const argsHash = hashOmit(args, []);
+      const transactionFetches = fetchesByArgsHash[argsHash] ||= {
+        args,
+        fetches: {}
+      };
+      const { callbacks: promiseCallbacksForSignature } = transactionFetches.fetches[signature] ||= {
+        callbacks: []
+      };
+      promiseCallbacksForSignature.push(orphanPromiseCallback);
+    });
+  });
+  return fetchesByArgsHash;
+}
+function buildCoalescedFetchesByArgsHashWithDataSlice(toFetchMap, maxDataSliceByteRange) {
+  const fetchesByArgsHash = {};
+  const orphanedFetches = {};
+  Object.entries(toFetchMap).forEach(([address, toFetch]) => {
+    toFetch.forEach(({ args, promiseCallback }) => {
+      if (!args.encoding) {
+        const toFetch2 = orphanedFetches[address] ||= [];
+        toFetch2.push({ args, promiseCallback });
+        return;
+      }
+      if (args.encoding != "base64+zstd" && args.dataSlice) {
+        const r = args.dataSlice;
+        for (const { fetches: fetchAddresses, args: fetchArgs } of Object.values(fetchesByArgsHash)) {
+          const addCallbackWithDataSlice = (updateDataSlice) => {
+            const { callbacks: promiseCallbacksForAddress2 } = fetchAddresses[address] ||= {
+              callbacks: []
+            };
+            promiseCallbacksForAddress2.push({
+              callback: promiseCallback,
+              dataSlice: args.dataSlice ?? null
+            });
+            if (fetchArgs.dataSlice && updateDataSlice) {
+              fetchArgs.dataSlice = updateDataSlice;
+            }
+          };
+          if (hashOmit(args, ["dataSlice"]) === hashOmit(fetchArgs, ["dataSlice"])) {
+            if (fetchArgs.dataSlice) {
+              const g = fetchArgs.dataSlice;
+              if (r.offset <= g.offset && g.offset - r.offset + r.length <= maxDataSliceByteRange) {
+                const length = Math.max(r.length, g.offset + g.length - r.offset);
+                const offset = r.offset;
+                addCallbackWithDataSlice({ length, offset });
+                return;
+              }
+              if (r.offset >= g.offset && r.offset - g.offset + g.length <= maxDataSliceByteRange) {
+                const length = Math.max(g.length, r.offset + r.length - g.offset);
+                const offset = g.offset;
+                addCallbackWithDataSlice({ length, offset });
+                return;
+              }
+            } else {
+              const { length, offset } = r;
+              addCallbackWithDataSlice({ length, offset });
+              return;
+            }
+          }
+        }
+      }
+      const argsHash = hashOmit(args, []);
+      const accountFetches = fetchesByArgsHash[argsHash] ||= {
+        args,
+        fetches: {}
+      };
+      const { callbacks: promiseCallbacksForAddress } = accountFetches.fetches[address] ||= {
+        callbacks: []
+      };
+      promiseCallbacksForAddress.push({ callback: promiseCallback, dataSlice: args.dataSlice ?? null });
+    });
+  });
+  Object.entries(orphanedFetches).forEach(([address, toFetch]) => {
+    toFetch.forEach(({ args: orphanedArgs, promiseCallback: orphanPromiseCallback }) => {
+      if (Object.keys(fetchesByArgsHash).length !== 0) {
+        for (const { fetches, args: args2 } of Object.values(fetchesByArgsHash)) {
+          if (hashOmit(orphanedArgs, ["encoding", "dataSlice"]) === hashOmit(args2, ["encoding", "dataSlice"])) {
+            const { callbacks: promiseCallbacksForAddress2 } = fetches[address] ||= {
+              callbacks: []
+            };
+            promiseCallbacksForAddress2.push({ callback: orphanPromiseCallback });
+            return;
+          }
+        }
+      }
+      const args = { ...orphanedArgs, encoding: "base64" };
+      const argsHash = hashOmit(args, []);
+      const accountFetches = fetchesByArgsHash[argsHash] ||= {
+        args,
+        fetches: {}
+      };
+      const { callbacks: promiseCallbacksForAddress } = accountFetches.fetches[address] ||= {
+        callbacks: []
+      };
+      promiseCallbacksForAddress.push({ callback: orphanPromiseCallback });
+    });
+  });
+  return fetchesByArgsHash;
+}
+
 // src/loaders/account.ts
 function getCodec(encoding) {
   switch (encoding) {
@@ -56,15 +201,6 @@ async function loadAccount(rpc, { address, ...config }) {
 async function loadMultipleAccounts(rpc, { addresses, ...config }) {
   return await rpc.getMultipleAccounts(addresses, config).send().then((res) => res.value);
 }
-var hashOmit = (args, omit) => {
-  const argsObj = {};
-  for (const [key, value] of Object.entries(args)) {
-    if (!omit.includes(key)) {
-      argsObj[key] = value;
-    }
-  }
-  return cacheKeyFn(argsObj);
-};
 function createAccountBatchLoadFn(rpc, config) {
   const resolveAccountUsingRpc = loadAccount.bind(null, rpc);
   const resolveMultipleAccountsUsingRpc = loadMultipleAccounts.bind(null, rpc);
@@ -84,92 +220,11 @@ function createAccountBatchLoadFn(rpc, config) {
       );
     } finally {
       const { maxDataSliceByteRange, maxMultipleAccountsBatchSize } = config;
-      const accountFetchesByArgsHash = {};
-      const orphanedFetches = {};
-      Object.entries(accountsToFetch).forEach(([address, toFetch]) => {
-        toFetch.forEach(({ args, promiseCallback }) => {
-          if (!args.encoding) {
-            const toFetch2 = orphanedFetches[address] ||= [];
-            toFetch2.push({ args, promiseCallback });
-            return;
-          }
-          if (args.encoding != "base64+zstd" && args.dataSlice) {
-            const r = args.dataSlice;
-            for (const { addresses: fetchAddresses, args: fetchArgs } of Object.values(
-              accountFetchesByArgsHash
-            )) {
-              const addCallbackWithDataSlice = (updateDataSlice) => {
-                const { callbacks: promiseCallbacksForAddress2 } = fetchAddresses[address] ||= {
-                  callbacks: []
-                };
-                promiseCallbacksForAddress2.push({
-                  callback: promiseCallback,
-                  dataSlice: args.dataSlice ?? null
-                });
-                if (fetchArgs.dataSlice && updateDataSlice) {
-                  fetchArgs.dataSlice = updateDataSlice;
-                }
-              };
-              if (hashOmit(args, ["dataSlice"]) === hashOmit(fetchArgs, ["dataSlice"])) {
-                if (fetchArgs.dataSlice) {
-                  const g = fetchArgs.dataSlice;
-                  if (r.offset <= g.offset && g.offset - r.offset + r.length <= maxDataSliceByteRange) {
-                    const length = Math.max(r.length, g.offset + g.length - r.offset);
-                    const offset = r.offset;
-                    addCallbackWithDataSlice({ length, offset });
-                    return;
-                  }
-                  if (r.offset >= g.offset && r.offset - g.offset + g.length <= maxDataSliceByteRange) {
-                    const length = Math.max(g.length, r.offset + r.length - g.offset);
-                    const offset = g.offset;
-                    addCallbackWithDataSlice({ length, offset });
-                    return;
-                  }
-                } else {
-                  const { length, offset } = r;
-                  addCallbackWithDataSlice({ length, offset });
-                  return;
-                }
-              }
-            }
-          }
-          const argsHash = hashOmit(args, []);
-          const accountFetches = accountFetchesByArgsHash[argsHash] ||= {
-            addresses: {},
-            args
-          };
-          const { callbacks: promiseCallbacksForAddress } = accountFetches.addresses[address] ||= {
-            callbacks: []
-          };
-          promiseCallbacksForAddress.push({ callback: promiseCallback, dataSlice: args.dataSlice ?? null });
-        });
-      });
-      Object.entries(orphanedFetches).forEach(([address, toFetch]) => {
-        toFetch.forEach(({ args: orphanedArgs, promiseCallback: orphanPromiseCallback }) => {
-          if (Object.keys(accountFetchesByArgsHash).length !== 0) {
-            for (const { addresses, args: args2 } of Object.values(accountFetchesByArgsHash)) {
-              if (hashOmit(orphanedArgs, ["encoding", "dataSlice"]) === hashOmit(args2, ["encoding", "dataSlice"])) {
-                const { callbacks: promiseCallbacksForAddress2 } = addresses[address] ||= {
-                  callbacks: []
-                };
-                promiseCallbacksForAddress2.push({ callback: orphanPromiseCallback });
-                return;
-              }
-            }
-          }
-          const args = { ...orphanedArgs, encoding: "base64" };
-          const argsHash = hashOmit(args, []);
-          const accountFetches = accountFetchesByArgsHash[argsHash] ||= {
-            addresses: {},
-            args
-          };
-          const { callbacks: promiseCallbacksForAddress } = accountFetches.addresses[address] ||= {
-            callbacks: []
-          };
-          promiseCallbacksForAddress.push({ callback: orphanPromiseCallback });
-        });
-      });
-      Object.values(accountFetchesByArgsHash).map(({ args, addresses: addressCallbacks }) => {
+      const accountFetchesByArgsHash = buildCoalescedFetchesByArgsHashWithDataSlice(
+        accountsToFetch,
+        maxDataSliceByteRange
+      );
+      Object.values(accountFetchesByArgsHash).map(({ args, fetches: addressCallbacks }) => {
         const addresses = Object.keys(addressCallbacks);
         if (addresses.length === 1) {
           const address = addresses[0];
@@ -224,23 +279,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,
@@ -250,30 +288,50 @@ 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(createBlockBatchLoadFn(rpc), { cacheKeyFn });
   return {
-    load: async (args) => loader.load(applyDefaultArgs(args)),
-    loadMany: async (args) => loader.loadMany(args.map(applyDefaultArgs))
-  };
-}
-function applyDefaultArgs2({
-  commitment,
-  dataSlice,
-  encoding = "jsonParsed",
-  filters,
-  minContextSlot,
-  programAddress
-}) {
-  return {
-    commitment,
-    dataSlice,
-    encoding,
-    filters,
-    minContextSlot,
-    programAddress
+    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 }) {
@@ -283,26 +341,50 @@ async function loadProgramAccounts(rpc, { programAddress, ...config }) {
     config
   ).send();
 }
-function createProgramAccountsBatchLoadFn(rpc) {
+function createProgramAccountsBatchLoadFn(rpc, config) {
   const resolveProgramAccountsUsingRpc = loadProgramAccounts.bind(null, rpc);
-  return async (programAccountsQueryArgs) => Promise.all(programAccountsQueryArgs.map(async (args) => resolveProgramAccountsUsingRpc(applyDefaultArgs2(args))));
-}
-function createProgramAccountsLoader(rpc) {
-  const loader = new DataLoader(createProgramAccountsBatchLoadFn(rpc), { cacheKeyFn });
-  return {
-    load: async (args) => loader.load(applyDefaultArgs2(args)),
-    loadMany: async (args) => loader.loadMany(args.map(applyDefaultArgs2))
+  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 } });
+        })
+      ));
+    } finally {
+      const { maxDataSliceByteRange } = config;
+      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 () => {
+            try {
+              const result = await resolveProgramAccountsUsingRpc({
+                programAddress,
+                ...args
+              });
+              callbacks.forEach(({ callback, dataSlice }) => {
+                callback.resolve(sliceData(result, dataSlice, args.dataSlice));
+              });
+            } catch (e) {
+              callbacks.forEach(({ callback }) => {
+                callback.reject(e);
+              });
+            }
+          });
+        });
+      });
+    }
   };
 }
-function applyDefaultArgs3({
-  commitment,
-  encoding = "jsonParsed",
-  signature
-}) {
+function createProgramAccountsLoader(rpc, config) {
+  const loader = new DataLoader(createProgramAccountsBatchLoadFn(rpc, config), { cacheKeyFn });
   return {
-    commitment,
-    encoding,
-    signature
+    load: async (args) => loader.load(args),
+    loadMany: async (args) => loader.loadMany(args)
   };
 }
 async function loadTransaction(rpc, { signature, ...config }) {
@@ -314,13 +396,47 @@ async function loadTransaction(rpc, { signature, ...config }) {
 }
 function createTransactionBatchLoadFn(rpc) {
   const resolveTransactionUsingRpc = loadTransaction.bind(null, rpc);
-  return async (transactionQueryArgs) => Promise.all(transactionQueryArgs.map(async (args) => resolveTransactionUsingRpc(applyDefaultArgs3(args))));
+  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 } });
+        })
+      ));
+    } finally {
+      const transactionFetchesByArgsHash = buildCoalescedFetchesByArgsHash(transactionsToFetch, {
+        criteria: (args) => args.encoding === void 0,
+        defaults: (args) => ({ ...args, encoding: "base64" }),
+        hashOmit: ["encoding"]
+      });
+      Object.values(transactionFetchesByArgsHash).map(({ args, fetches: transactionCallbacks }) => {
+        return Object.entries(transactionCallbacks).map(([signature, { callbacks }]) => {
+          return Array.from({ length: 1 }, async () => {
+            try {
+              const result = await resolveTransactionUsingRpc({
+                signature,
+                ...args
+              });
+              callbacks.forEach((c) => c.resolve(result));
+            } catch (e) {
+              callbacks.forEach((c) => c.reject(e));
+            }
+          });
+        });
+      });
+    }
+  };
 }
 function createTransactionLoader(rpc) {
   const loader = new DataLoader(createTransactionBatchLoadFn(rpc), { cacheKeyFn });
   return {
-    load: async (args) => loader.load(applyDefaultArgs3(args)),
-    loadMany: async (args) => loader.loadMany(args.map(applyDefaultArgs3))
+    load: async (args) => loader.load(args),
+    loadMany: async (args) => loader.loadMany(args)
   };
 }
 
@@ -330,7 +446,7 @@ function createSolanaGraphQLContext(rpc, config) {
     loaders: {
       account: createAccountLoader(rpc, config),
       block: createBlockLoader(rpc),
-      programAccounts: createProgramAccountsLoader(rpc),
+      programAccounts: createProgramAccountsLoader(rpc, config),
       transaction: createTransactionLoader(rpc)
     }
   };
@@ -420,7 +536,7 @@ function parseAccountDataSliceArgument(argumentNodes, variableValues) {
     return void 0;
   }
 }
-function buildAccountLoaderArgSetFromResolveInfo(args, info) {
+function buildAccountArgSetWithVisitor(args, info) {
   const argSet = [args];
   function buildArgSetWithVisitor(root) {
     injectableRootVisitor(info, root, {
@@ -452,6 +568,93 @@ function buildAccountLoaderArgSetFromResolveInfo(args, info) {
   buildArgSetWithVisitor(null);
   return argSet;
 }
+function buildAccountLoaderArgSetFromResolveInfo(args, info) {
+  return buildAccountArgSetWithVisitor(args, info);
+}
+
+// src/resolvers/resolve-info/transaction.ts
+function findArgumentNodeByName2(argumentNodes, name) {
+  return argumentNodes.find((argumentNode) => argumentNode.name.value === name);
+}
+function parseTransactionEncodingArgument(argumentNodes, variableValues) {
+  const argumentNode = findArgumentNodeByName2(argumentNodes, "encoding");
+  if (argumentNode) {
+    if (argumentNode.value.kind === "EnumValue") {
+      if (argumentNode.value.value === "BASE_58") {
+        return "base58";
+      }
+      if (argumentNode.value.value === "BASE_64") {
+        return "base64";
+      }
+    }
+    if (argumentNode.value.kind === "Variable") {
+      return variableValues[argumentNode.value.name.value];
+    }
+  } else {
+    return void 0;
+  }
+}
+function buildTransactionArgSetWithVisitor(args, info) {
+  const argSet = [args];
+  function buildArgSetWithVisitor(root) {
+    injectableRootVisitor(info, root, {
+      fieldNodeOperation(info2, node) {
+        if (node.name.value === "message" || node.name.value === "meta") {
+          argSet.push({ ...args, encoding: "jsonParsed" });
+        } else if (node.name.value === "data") {
+          if (node.arguments) {
+            const { variableValues } = info2;
+            const encoding = parseTransactionEncodingArgument(
+              node.arguments,
+              variableValues
+            );
+            argSet.push({ ...args, encoding });
+          }
+        }
+      },
+      fragmentSpreadNodeOperation(_info, fragment) {
+        buildArgSetWithVisitor(fragment);
+      },
+      inlineFragmentNodeOperation(_info, _node) {
+        return;
+      }
+    });
+  }
+  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 = () => {
@@ -604,147 +807,207 @@ var accountResolvers = {
 };
 
 // src/resolvers/transaction.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;
+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)
+  }));
 }
+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) {
-      return null;
-    }
-    if (onlyFieldsRequested(["signature"], info)) {
-      return { signature };
-    }
-    const transaction = await context.loaders.transaction.load({ ...args, signature });
-    if (!transaction) {
-      return null;
-    }
-    if (args.encoding !== "jsonParsed") {
-      const transactionJsonParsed = await context.loaders.transaction.load({
-        ...args,
-        encoding: "jsonParsed",
+    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
+              };
+            }
+          }
+        }
       });
-      if (transactionJsonParsed === null) {
-        return null;
-      }
-      transaction.meta = transactionJsonParsed.meta;
+      return result;
     }
-    return transformLoadedTransaction({ encoding: args.encoding, transaction });
+    return null;
   };
 }
 var transactionResolvers = {
   Transaction: {
-    __resolveType(transaction) {
-      switch (transaction.encoding) {
-        case "base58":
-          return "TransactionBase58";
-        case "base64":
-          return "TransactionBase64";
-        default:
-          return "TransactionParsed";
-      }
-    }
+    data: resolveTransactionData()
   }
 };
 
 // src/resolvers/block.ts
-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 });
-      }
-    });
-  }
-  block.encoding = encoding;
-  block.transactionDetails = transactionDetails;
-  return block;
-}
 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
   }
 };
 
@@ -752,7 +1015,8 @@ var blockResolvers = {
 var instructionResolvers = {
   AdvanceNonceAccountInstruction: {
     nonceAccount: resolveAccount("nonceAccount"),
-    nonceAuthority: resolveAccount("nonceAuthority")
+    nonceAuthority: resolveAccount("nonceAuthority"),
+    recentBlockhashesSysvar: resolveAccount("recentBlockhashesSysvar")
   },
   AllocateInstruction: {
     account: resolveAccount("account")
@@ -789,9 +1053,11 @@ var instructionResolvers = {
   BpfUpgradeableLoaderDeployWithMaxDataLenInstruction: {
     authority: resolveAccount("authority"),
     bufferAccount: resolveAccount("bufferAccount"),
+    clockSysvar: resolveAccount("clockSysvar"),
     payerAccount: resolveAccount("payerAccount"),
     programAccount: resolveAccount("programAccount"),
-    programDataAccount: resolveAccount("programDataAccount")
+    programDataAccount: resolveAccount("programDataAccount"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   BpfUpgradeableLoaderExtendProgramInstruction: {
     payerAccount: resolveAccount("payerAccount"),
@@ -815,8 +1081,10 @@ var instructionResolvers = {
   BpfUpgradeableLoaderUpgradeInstruction: {
     authority: resolveAccount("authority"),
     bufferAccount: resolveAccount("bufferAccount"),
+    clockSysvar: resolveAccount("clockSysvar"),
     programAccount: resolveAccount("programAccount"),
-    programDataAccount: resolveAccount("programDataAccount")
+    programDataAccount: resolveAccount("programDataAccount"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   BpfUpgradeableLoaderWriteInstruction: {
     account: resolveAccount("account"),
@@ -859,7 +1127,9 @@ var instructionResolvers = {
   },
   InitializeNonceAccountInstruction: {
     nonceAccount: resolveAccount("nonceAccount"),
-    nonceAuthority: resolveAccount("nonceAuthority")
+    nonceAuthority: resolveAccount("nonceAuthority"),
+    recentBlockhashesSysvar: resolveAccount("recentBlockhashesSysvar"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   Lockup: {
     custodian: resolveAccount("custodian")
@@ -935,7 +1205,8 @@ var instructionResolvers = {
   SplTokenInitializeAccount2Instruction: {
     account: resolveAccount("account"),
     mint: resolveAccount("mint"),
-    owner: resolveAccount("owner")
+    owner: resolveAccount("owner"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   SplTokenInitializeAccount3Instruction: {
     account: resolveAccount("account"),
@@ -945,7 +1216,8 @@ var instructionResolvers = {
   SplTokenInitializeAccountInstruction: {
     account: resolveAccount("account"),
     mint: resolveAccount("mint"),
-    owner: resolveAccount("owner")
+    owner: resolveAccount("owner"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   SplTokenInitializeMint2Instruction: {
     freezeAuthority: resolveAccount("freezeAuthority"),
@@ -959,13 +1231,15 @@ var instructionResolvers = {
   SplTokenInitializeMintInstruction: {
     freezeAuthority: resolveAccount("freezeAuthority"),
     mint: resolveAccount("mint"),
-    mintAuthority: resolveAccount("mintAuthority")
+    mintAuthority: resolveAccount("mintAuthority"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   SplTokenInitializeMultisig2Instruction: {
     multisig: resolveAccount("multisig")
   },
   SplTokenInitializeMultisigInstruction: {
-    multisig: resolveAccount("multisig")
+    multisig: resolveAccount("multisig"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   SplTokenMintToCheckedInstruction: {
     account: resolveAccount("account"),
@@ -1018,6 +1292,7 @@ var instructionResolvers = {
   },
   StakeAuthorizeCheckedInstruction: {
     authority: resolveAccount("authority"),
+    clockSysvar: resolveAccount("clockSysvar"),
     custodian: resolveAccount("custodian"),
     newAuthority: resolveAccount("newAuthority"),
     stakeAccount: resolveAccount("stakeAccount")
@@ -1025,12 +1300,14 @@ var instructionResolvers = {
   StakeAuthorizeCheckedWithSeedInstruction: {
     authorityBase: resolveAccount("authorityBase"),
     authorityOwner: resolveAccount("authorityOwner"),
+    clockSysvar: resolveAccount("clockSysvar"),
     custodian: resolveAccount("custodian"),
     newAuthorized: resolveAccount("newAuthorized"),
     stakeAccount: resolveAccount("stakeAccount")
   },
   StakeAuthorizeInstruction: {
     authority: resolveAccount("authority"),
+    clockSysvar: resolveAccount("clockSysvar"),
     custodian: resolveAccount("custodian"),
     newAuthority: resolveAccount("newAuthority"),
     stakeAccount: resolveAccount("stakeAccount")
@@ -1038,6 +1315,7 @@ var instructionResolvers = {
   StakeAuthorizeWithSeedInstruction: {
     authorityBase: resolveAccount("authorityBase"),
     authorityOwner: resolveAccount("authorityOwner"),
+    clockSysvar: resolveAccount("clockSysvar"),
     custodian: resolveAccount("custodian"),
     newAuthorized: resolveAccount("newAuthorized"),
     stakeAccount: resolveAccount("stakeAccount")
@@ -1048,20 +1326,28 @@ var instructionResolvers = {
     voteAccount: resolveAccount("voteAccount")
   },
   StakeDeactivateInstruction: {
+    clockSysvar: resolveAccount("clockSysvar"),
     stakeAccount: resolveAccount("stakeAccount"),
     stakeAuthority: resolveAccount("stakeAuthority")
   },
   StakeDelegateStakeInstruction: {
+    clockSysvar: resolveAccount("clockSysvar"),
     stakeAccount: resolveAccount("stakeAccount"),
     stakeAuthority: resolveAccount("stakeAuthority"),
     stakeConfigAccount: resolveAccount("stakeConfigAccount"),
+    stakeHistorySysvar: resolveAccount("stakeHistorySysvar"),
     voteAccount: resolveAccount("voteAccount")
   },
+  StakeInitializeCheckedInstruction: {
+    rentSysvar: resolveAccount("rentSysvar"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
   StakeInitializeCheckedInstructionDataAuthorized: {
     staker: resolveAccount("staker"),
     withdrawer: resolveAccount("withdrawer")
   },
   StakeInitializeInstruction: {
+    rentSysvar: resolveAccount("rentSysvar"),
     stakeAccount: resolveAccount("stakeAccount")
   },
   StakeInitializeInstructionDataAuthorized: {
@@ -1069,9 +1355,11 @@ var instructionResolvers = {
     withdrawer: resolveAccount("withdrawer")
   },
   StakeMergeInstruction: {
+    clockSysvar: resolveAccount("clockSysvar"),
     destination: resolveAccount("destination"),
     source: resolveAccount("source"),
-    stakeAuthority: resolveAccount("stakeAuthority")
+    stakeAuthority: resolveAccount("stakeAuthority"),
+    stakeHistorySysvar: resolveAccount("stakeHistorySysvar")
   },
   StakeRedelegateInstruction: {
     newStakeAccount: resolveAccount("newStakeAccount"),
@@ -1094,287 +1382,289 @@ var instructionResolvers = {
     stakeAuthority: resolveAccount("stakeAuthority")
   },
   StakeWithdrawInstruction: {
+    clockSysvar: resolveAccount("clockSysvar"),
     destination: resolveAccount("destination"),
     stakeAccount: resolveAccount("stakeAccount"),
     withdrawAuthority: resolveAccount("withdrawAuthority")
   },
   TransactionInstruction: {
-    __resolveType(instruction) {
-      if (instruction.programName) {
-        if (instruction.programName === "address-lookup-table") {
-          if (instruction.instructionType === "createLookupTable") {
+    __resolveType(instructionResult) {
+      const { jsonParsedConfigs } = instructionResult;
+      if (jsonParsedConfigs) {
+        if (jsonParsedConfigs.programName === "address-lookup-table") {
+          if (jsonParsedConfigs.instructionType === "createLookupTable") {
             return "CreateLookupTableInstruction";
           }
-          if (instruction.instructionType === "freezeLookupTable") {
+          if (jsonParsedConfigs.instructionType === "freezeLookupTable") {
             return "FreezeLookupTableInstruction";
           }
-          if (instruction.instructionType === "extendLookupTable") {
+          if (jsonParsedConfigs.instructionType === "extendLookupTable") {
             return "ExtendLookupTableInstruction";
           }
-          if (instruction.instructionType === "deactivateLookupTable") {
+          if (jsonParsedConfigs.instructionType === "deactivateLookupTable") {
             return "DeactivateLookupTableInstruction";
           }
-          if (instruction.instructionType === "closeLookupTable") {
+          if (jsonParsedConfigs.instructionType === "closeLookupTable") {
             return "CloseLookupTableInstruction";
           }
         }
-        if (instruction.programName === "bpf-loader") {
-          if (instruction.instructionType === "write") {
+        if (jsonParsedConfigs.programName === "bpf-loader") {
+          if (jsonParsedConfigs.instructionType === "write") {
             return "BpfLoaderWriteInstruction";
           }
-          if (instruction.instructionType === "finalize") {
+          if (jsonParsedConfigs.instructionType === "finalize") {
             return "BpfLoaderFinalizeInstruction";
           }
         }
-        if (instruction.programName === "bpf-upgradeable-loader") {
-          if (instruction.instructionType === "initializeBuffer") {
+        if (jsonParsedConfigs.programName === "bpf-upgradeable-loader") {
+          if (jsonParsedConfigs.instructionType === "initializeBuffer") {
             return "BpfUpgradeableLoaderInitializeBufferInstruction";
           }
-          if (instruction.instructionType === "write") {
+          if (jsonParsedConfigs.instructionType === "write") {
             return "BpfUpgradeableLoaderWriteInstruction";
           }
-          if (instruction.instructionType === "deployWithMaxDataLen") {
+          if (jsonParsedConfigs.instructionType === "deployWithMaxDataLen") {
             return "BpfUpgradeableLoaderDeployWithMaxDataLenInstruction";
           }
-          if (instruction.instructionType === "upgrade") {
+          if (jsonParsedConfigs.instructionType === "upgrade") {
             return "BpfUpgradeableLoaderUpgradeInstruction";
           }
-          if (instruction.instructionType === "setAuthority") {
+          if (jsonParsedConfigs.instructionType === "setAuthority") {
             return "BpfUpgradeableLoaderSetAuthorityInstruction";
           }
-          if (instruction.instructionType === "setAuthorityChecked") {
+          if (jsonParsedConfigs.instructionType === "setAuthorityChecked") {
             return "BpfUpgradeableLoaderSetAuthorityCheckedInstruction";
           }
-          if (instruction.instructionType === "close") {
+          if (jsonParsedConfigs.instructionType === "close") {
             return "BpfUpgradeableLoaderCloseInstruction";
           }
-          if (instruction.instructionType === "extendProgram") {
+          if (jsonParsedConfigs.instructionType === "extendProgram") {
             return "BpfUpgradeableLoaderExtendProgramInstruction";
           }
         }
-        if (instruction.programName === "spl-associated-token-account") {
-          if (instruction.instructionType === "create") {
+        if (jsonParsedConfigs.programName === "spl-associated-token-account") {
+          if (jsonParsedConfigs.instructionType === "create") {
             return "SplAssociatedTokenCreateInstruction";
           }
-          if (instruction.instructionType === "createIdempotent") {
+          if (jsonParsedConfigs.instructionType === "createIdempotent") {
             return "SplAssociatedTokenCreateIdempotentInstruction";
           }
-          if (instruction.instructionType === "recoverNested") {
+          if (jsonParsedConfigs.instructionType === "recoverNested") {
             return "SplAssociatedTokenRecoverNestedInstruction";
           }
         }
-        if (instruction.programName === "spl-memo") {
+        if (jsonParsedConfigs.programName === "spl-memo") {
           return "SplMemoInstruction";
         }
-        if (instruction.programName === "spl-token") {
-          if (instruction.instructionType === "initializeMint") {
+        if (jsonParsedConfigs.programName === "spl-token") {
+          if (jsonParsedConfigs.instructionType === "initializeMint") {
             return "SplTokenInitializeMintInstruction";
           }
-          if (instruction.instructionType === "initializeMint2") {
+          if (jsonParsedConfigs.instructionType === "initializeMint2") {
             return "SplTokenInitializeMint2Instruction";
           }
-          if (instruction.instructionType === "initializeAccount") {
+          if (jsonParsedConfigs.instructionType === "initializeAccount") {
             return "SplTokenInitializeAccountInstruction";
           }
-          if (instruction.instructionType === "initializeAccount2") {
+          if (jsonParsedConfigs.instructionType === "initializeAccount2") {
             return "SplTokenInitializeAccount2Instruction";
           }
-          if (instruction.instructionType === "initializeAccount3") {
+          if (jsonParsedConfigs.instructionType === "initializeAccount3") {
             return "SplTokenInitializeAccount3Instruction";
           }
-          if (instruction.instructionType === "initializeMultisig") {
+          if (jsonParsedConfigs.instructionType === "initializeMultisig") {
             return "SplTokenInitializeMultisigInstruction";
           }
-          if (instruction.instructionType === "initializeMultisig2") {
+          if (jsonParsedConfigs.instructionType === "initializeMultisig2") {
             return "SplTokenInitializeMultisig2Instruction";
           }
-          if (instruction.instructionType === "transfer") {
+          if (jsonParsedConfigs.instructionType === "transfer") {
             return "SplTokenTransferInstruction";
           }
-          if (instruction.instructionType === "approve") {
+          if (jsonParsedConfigs.instructionType === "approve") {
             return "SplTokenApproveInstruction";
           }
-          if (instruction.instructionType === "revoke") {
+          if (jsonParsedConfigs.instructionType === "revoke") {
             return "SplTokenRevokeInstruction";
           }
-          if (instruction.instructionType === "setAuthority") {
+          if (jsonParsedConfigs.instructionType === "setAuthority") {
             return "SplTokenSetAuthorityInstruction";
           }
-          if (instruction.instructionType === "mintTo") {
+          if (jsonParsedConfigs.instructionType === "mintTo") {
             return "SplTokenMintToInstruction";
           }
-          if (instruction.instructionType === "burn") {
+          if (jsonParsedConfigs.instructionType === "burn") {
             return "SplTokenBurnInstruction";
           }
-          if (instruction.instructionType === "closeAccount") {
+          if (jsonParsedConfigs.instructionType === "closeAccount") {
             return "SplTokenCloseAccountInstruction";
           }
-          if (instruction.instructionType === "freezeAccount") {
+          if (jsonParsedConfigs.instructionType === "freezeAccount") {
             return "SplTokenFreezeAccountInstruction";
           }
-          if (instruction.instructionType === "thawAccount") {
+          if (jsonParsedConfigs.instructionType === "thawAccount") {
             return "SplTokenThawAccountInstruction";
           }
-          if (instruction.instructionType === "transferChecked") {
+          if (jsonParsedConfigs.instructionType === "transferChecked") {
             return "SplTokenTransferCheckedInstruction";
           }
-          if (instruction.instructionType === "approveChecked") {
+          if (jsonParsedConfigs.instructionType === "approveChecked") {
             return "SplTokenApproveCheckedInstruction";
           }
-          if (instruction.instructionType === "mintToChecked") {
+          if (jsonParsedConfigs.instructionType === "mintToChecked") {
             return "SplTokenMintToCheckedInstruction";
           }
-          if (instruction.instructionType === "burnChecked") {
+          if (jsonParsedConfigs.instructionType === "burnChecked") {
             return "SplTokenBurnCheckedInstruction";
           }
-          if (instruction.instructionType === "syncNative") {
+          if (jsonParsedConfigs.instructionType === "syncNative") {
             return "SplTokenSyncNativeInstruction";
           }
-          if (instruction.instructionType === "getAccountDataSize") {
+          if (jsonParsedConfigs.instructionType === "getAccountDataSize") {
             return "SplTokenGetAccountDataSizeInstruction";
           }
-          if (instruction.instructionType === "initializeImmutableOwner") {
+          if (jsonParsedConfigs.instructionType === "initializeImmutableOwner") {
             return "SplTokenInitializeImmutableOwnerInstruction";
           }
-          if (instruction.instructionType === "amountToUiAmount") {
+          if (jsonParsedConfigs.instructionType === "amountToUiAmount") {
             return "SplTokenAmountToUiAmountInstruction";
           }
-          if (instruction.instructionType === "uiAmountToAmount") {
+          if (jsonParsedConfigs.instructionType === "uiAmountToAmount") {
             return "SplTokenUiAmountToAmountInstruction";
           }
-          if (instruction.instructionType === "initializeMintCloseAuthority") {
+          if (jsonParsedConfigs.instructionType === "initializeMintCloseAuthority") {
             return "SplTokenInitializeMintCloseAuthorityInstruction";
           }
         }
-        if (instruction.programName === "stake") {
-          if (instruction.instructionType === "initialize") {
+        if (jsonParsedConfigs.programName === "stake") {
+          if (jsonParsedConfigs.instructionType === "initialize") {
             return "StakeInitializeInstruction";
           }
-          if (instruction.instructionType === "authorize") {
+          if (jsonParsedConfigs.instructionType === "authorize") {
             return "StakeAuthorizeInstruction";
           }
-          if (instruction.instructionType === "delegate") {
+          if (jsonParsedConfigs.instructionType === "delegate") {
             return "StakeDelegateStakeInstruction";
           }
-          if (instruction.instructionType === "split") {
+          if (jsonParsedConfigs.instructionType === "split") {
             return "StakeSplitInstruction";
           }
-          if (instruction.instructionType === "withdraw") {
+          if (jsonParsedConfigs.instructionType === "withdraw") {
             return "StakeWithdrawInstruction";
           }
-          if (instruction.instructionType === "deactivate") {
+          if (jsonParsedConfigs.instructionType === "deactivate") {
             return "StakeDeactivateInstruction";
           }
-          if (instruction.instructionType === "setLockup") {
+          if (jsonParsedConfigs.instructionType === "setLockup") {
             return "StakeSetLockupInstruction";
           }
-          if (instruction.instructionType === "merge") {
+          if (jsonParsedConfigs.instructionType === "merge") {
             return "StakeMergeInstruction";
           }
-          if (instruction.instructionType === "authorizeWithSeed") {
+          if (jsonParsedConfigs.instructionType === "authorizeWithSeed") {
             return "StakeAuthorizeWithSeedInstruction";
           }
-          if (instruction.instructionType === "initializeChecked") {
+          if (jsonParsedConfigs.instructionType === "initializeChecked") {
             return "StakeInitializeCheckedInstruction";
           }
-          if (instruction.instructionType === "authorizeChecked") {
+          if (jsonParsedConfigs.instructionType === "authorizeChecked") {
             return "StakeAuthorizeCheckedInstruction";
           }
-          if (instruction.instructionType === "authorizeCheckedWithSeed") {
+          if (jsonParsedConfigs.instructionType === "authorizeCheckedWithSeed") {
             return "StakeAuthorizeCheckedWithSeedInstruction";
           }
-          if (instruction.instructionType === "setLockupChecked") {
+          if (jsonParsedConfigs.instructionType === "setLockupChecked") {
             return "StakeSetLockupCheckedInstruction";
           }
-          if (instruction.instructionType === "deactivateDelinquent") {
+          if (jsonParsedConfigs.instructionType === "deactivateDelinquent") {
             return "StakeDeactivateDelinquentInstruction";
           }
-          if (instruction.instructionType === "redelegate") {
+          if (jsonParsedConfigs.instructionType === "redelegate") {
             return "StakeRedelegateInstruction";
           }
         }
-        if (instruction.programName === "system") {
-          if (instruction.instructionType === "createAccount") {
+        if (jsonParsedConfigs.programName === "system") {
+          if (jsonParsedConfigs.instructionType === "createAccount") {
             return "CreateAccountInstruction";
           }
-          if (instruction.instructionType === "assign") {
+          if (jsonParsedConfigs.instructionType === "assign") {
             return "AssignInstruction";
           }
-          if (instruction.instructionType === "transfer") {
+          if (jsonParsedConfigs.instructionType === "transfer") {
             return "TransferInstruction";
           }
-          if (instruction.instructionType === "createAccountWithSeed") {
+          if (jsonParsedConfigs.instructionType === "createAccountWithSeed") {
             return "CreateAccountWithSeedInstruction";
           }
-          if (instruction.instructionType === "advanceNonceAccount") {
+          if (jsonParsedConfigs.instructionType === "advanceNonceAccount") {
             return "AdvanceNonceAccountInstruction";
           }
-          if (instruction.instructionType === "withdrawNonceAccount") {
+          if (jsonParsedConfigs.instructionType === "withdrawNonceAccount") {
             return "WithdrawNonceAccountInstruction";
           }
-          if (instruction.instructionType === "initializeNonceAccount") {
+          if (jsonParsedConfigs.instructionType === "initializeNonceAccount") {
             return "InitializeNonceAccountInstruction";
           }
-          if (instruction.instructionType === "authorizeNonceAccount") {
+          if (jsonParsedConfigs.instructionType === "authorizeNonceAccount") {
             return "AuthorizeNonceAccountInstruction";
           }
-          if (instruction.instructionType === "upgradeNonceAccount") {
+          if (jsonParsedConfigs.instructionType === "upgradeNonceAccount") {
             return "UpgradeNonceAccountInstruction";
           }
-          if (instruction.instructionType === "allocate") {
+          if (jsonParsedConfigs.instructionType === "allocate") {
             return "AllocateInstruction";
           }
-          if (instruction.instructionType === "allocateWithSeed") {
+          if (jsonParsedConfigs.instructionType === "allocateWithSeed") {
             return "AllocateWithSeedInstruction";
           }
-          if (instruction.instructionType === "assignWithSeed") {
+          if (jsonParsedConfigs.instructionType === "assignWithSeed") {
             return "AssignWithSeedInstruction";
           }
-          if (instruction.instructionType === "transferWithSeed") {
+          if (jsonParsedConfigs.instructionType === "transferWithSeed") {
             return "TransferWithSeedInstruction";
           }
         }
-        if (instruction.programName === "vote") {
-          if (instruction.instructionType === "initialize") {
+        if (jsonParsedConfigs.programName === "vote") {
+          if (jsonParsedConfigs.instructionType === "initialize") {
             return "VoteInitializeAccountInstruction";
           }
-          if (instruction.instructionType === "authorize") {
+          if (jsonParsedConfigs.instructionType === "authorize") {
             return "VoteAuthorizeInstruction";
           }
-          if (instruction.instructionType === "authorizeWithSeed") {
+          if (jsonParsedConfigs.instructionType === "authorizeWithSeed") {
             return "VoteAuthorizeWithSeedInstruction";
           }
-          if (instruction.instructionType === "authorizeCheckedWithSeed") {
+          if (jsonParsedConfigs.instructionType === "authorizeCheckedWithSeed") {
             return "VoteAuthorizeCheckedWithSeedInstruction";
           }
-          if (instruction.instructionType === "vote") {
+          if (jsonParsedConfigs.instructionType === "vote") {
             return "VoteVoteInstruction";
           }
-          if (instruction.instructionType === "updatevotestate") {
+          if (jsonParsedConfigs.instructionType === "updatevotestate") {
             return "VoteUpdateVoteStateInstruction";
           }
-          if (instruction.instructionType === "updatevotestateswitch") {
+          if (jsonParsedConfigs.instructionType === "updatevotestateswitch") {
             return "VoteUpdateVoteStateSwitchInstruction";
           }
-          if (instruction.instructionType === "compactupdatevotestate") {
+          if (jsonParsedConfigs.instructionType === "compactupdatevotestate") {
             return "VoteCompactUpdateVoteStateInstruction";
           }
-          if (instruction.instructionType === "compactupdatevotestateswitch") {
+          if (jsonParsedConfigs.instructionType === "compactupdatevotestateswitch") {
             return "VoteCompactUpdateVoteStateSwitchInstruction";
           }
-          if (instruction.instructionType === "withdraw") {
+          if (jsonParsedConfigs.instructionType === "withdraw") {
             return "VoteWithdrawInstruction";
           }
-          if (instruction.instructionType === "updateValidatorIdentity") {
+          if (jsonParsedConfigs.instructionType === "updateValidatorIdentity") {
             return "VoteUpdateValidatorIdentityInstruction";
           }
-          if (instruction.instructionType === "updateCommission") {
+          if (jsonParsedConfigs.instructionType === "updateCommission") {
             return "VoteUpdateCommissionInstruction";
           }
-          if (instruction.instructionType === "voteSwitch") {
+          if (jsonParsedConfigs.instructionType === "voteSwitch") {
             return "VoteVoteSwitchInstruction";
           }
-          if (instruction.instructionType === "authorizeChecked") {
+          if (jsonParsedConfigs.instructionType === "authorizeChecked") {
             return "VoteAuthorizeCheckedInstruction";
           }
         }
@@ -1397,21 +1687,25 @@ var instructionResolvers = {
   },
   VoteAuthorizeCheckedInstruction: {
     authority: resolveAccount("authority"),
+    clockSysvar: resolveAccount("clockSysvar"),
     newAuthority: resolveAccount("newAuthority"),
     voteAccount: resolveAccount("voteAccount")
   },
   VoteAuthorizeCheckedWithSeedInstruction: {
     authorityOwner: resolveAccount("authorityOwner"),
+    clockSysvar: resolveAccount("clockSysvar"),
     newAuthority: resolveAccount("newAuthority"),
     voteAccount: resolveAccount("voteAccount")
   },
   VoteAuthorizeInstruction: {
     authority: resolveAccount("authority"),
+    clockSysvar: resolveAccount("clockSysvar"),
     newAuthority: resolveAccount("newAuthority"),
     voteAccount: resolveAccount("voteAccount")
   },
   VoteAuthorizeWithSeedInstruction: {
     authorityOwner: resolveAccount("authorityOwner"),
+    clockSysvar: resolveAccount("clockSysvar"),
     newAuthority: resolveAccount("newAuthority"),
     voteAccount: resolveAccount("voteAccount")
   },
@@ -1426,7 +1720,9 @@ var instructionResolvers = {
   VoteInitializeAccountInstruction: {
     authorizedVoter: resolveAccount("authorizedVoter"),
     authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
+    clockSysvar: resolveAccount("clockSysvar"),
     node: resolveAccount("node"),
+    rentSysvar: resolveAccount("rentSysvar"),
     voteAccount: resolveAccount("voteAccount")
   },
   VoteUpdateCommissionInstruction: {
@@ -1447,10 +1743,14 @@ var instructionResolvers = {
     voteAuthority: resolveAccount("voteAuthority")
   },
   VoteVoteInstruction: {
+    clockSysvar: resolveAccount("clockSysvar"),
+    slotHashesSysvar: resolveAccount("slotHashesSysvar"),
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
   VoteVoteSwitchInstruction: {
+    clockSysvar: resolveAccount("clockSysvar"),
+    slotHashesSysvar: resolveAccount("slotHashesSysvar"),
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
@@ -1461,7 +1761,9 @@ var instructionResolvers = {
   WithdrawNonceAccountInstruction: {
     destination: resolveAccount("destination"),
     nonceAccount: resolveAccount("nonceAccount"),
-    nonceAuthority: resolveAccount("nonceAuthority")
+    nonceAuthority: resolveAccount("nonceAuthority"),
+    recentBlockhashesSysvar: resolveAccount("recentBlockhashesSysvar"),
+    rentSysvar: resolveAccount("rentSysvar")
   }
 };
 
@@ -1470,52 +1772,54 @@ function resolveProgramAccounts(fieldName) {
   return async (parent, args, context, info) => {
     const programAddress = fieldName ? parent[fieldName] : args.programAddress;
     if (programAddress) {
-      if (onlyFieldsRequested(["programAddress"], info)) {
-        return { programAddress };
-      }
-    }
-    const programAccounts = await context.loaders.programAccounts.load({ ...args, programAddress });
-    if (programAccounts) {
-      return programAccounts.map((programAccount) => {
-        const { account, pubkey: address } = programAccount;
-        let result = {
-          ...account,
-          address,
-          encodedData: {},
-          ownerProgram: account.owner
-        };
-        const { data } = account;
-        const { encoding, dataSlice } = args;
-        if (result.encodedData) {
-          if (Array.isArray(data)) {
-            result.encodedData[cacheKeyFn({
-              dataSlice,
-              encoding: encoding === "jsonParsed" ? "base64" : encoding ?? "base64"
-            })] = data[0];
-          } else if (typeof data === "string") {
-            result.encodedData[cacheKeyFn({
-              dataSlice,
-              encoding: "base58"
-            })] = data;
-          } else if (typeof data === "object") {
-            const {
-              parsed: { info: parsedData, type: accountType },
-              program: programName,
-              programId
-            } = data;
-            result.jsonParsedConfigs = {
-              accountType,
-              programId,
-              programName
-            };
-            result = {
-              ...result,
-              ...parsedData
-            };
-          }
+      const argsSet = buildProgramAccountsLoaderArgSetFromResolveInfo({ ...args, programAddress }, info);
+      const loadedProgramAccountsLists = await context.loaders.programAccounts.loadMany(argsSet);
+      const result = {};
+      loadedProgramAccountsLists.forEach((programAccounts, i) => {
+        if (programAccounts instanceof Error) {
+          console.error(programAccounts);
+          return;
         }
-        return result;
+        programAccounts.forEach((programAccount) => {
+          const { account, pubkey: address } = programAccount;
+          const thisResult = result[address] ||= {
+            ...account,
+            address,
+            encodedData: {},
+            ownerProgram: account.owner
+          };
+          const { data } = account;
+          const { encoding, dataSlice } = argsSet[i];
+          if (encoding && thisResult.encodedData) {
+            if (Array.isArray(data)) {
+              thisResult.encodedData[cacheKeyFn({
+                dataSlice,
+                encoding: encoding === "jsonParsed" ? "base64" : encoding
+              })] = data[0];
+            } else if (typeof data === "string") {
+              thisResult.encodedData[cacheKeyFn({
+                dataSlice,
+                encoding: "base58"
+              })] = data;
+            } else if (typeof data === "object") {
+              const {
+                parsed: { info: parsedData, type: accountType },
+                program: programName,
+                programId
+              } = data;
+              thisResult.jsonParsedConfigs = {
+                accountType,
+                programId,
+                programName
+              };
+              for (const key in parsedData) {
+                thisResult[key] = parsedData[key];
+              }
+            }
+          }
+        });
       });
+      return Object.values(result);
     }
     return null;
   };
@@ -1546,7 +1850,7 @@ var stringScalarAlias = {
 };
 var bigIntScalarAlias = {
   __parseLiteral(ast) {
-    if (ast.kind === Kind.STRING) {
+    if (ast.kind === Kind.STRING || ast.kind === Kind.INT || ast.kind === Kind.FLOAT) {
       return BigInt(ast.value);
     }
     return null;
@@ -1569,17 +1873,15 @@ var typeTypeResolvers = {
   Base64EncodedBytes: stringScalarAlias,
   Base64ZstdEncodedBytes: stringScalarAlias,
   BigInt: bigIntScalarAlias,
-  BlockTransactionDetails: {
-    ACCOUNTS: "accounts",
-    FULL: "full",
-    NONE: "none",
-    SIGNATURES: "signatures"
-  },
   Commitment: {
     CONFIRMED: "confirmed",
     FINALIZED: "finalized",
     PROCESSED: "processed"
   },
+  CommitmentWithoutProcessed: {
+    CONFIRMED: "confirmed",
+    FINALIZED: "finalized"
+  },
   Signature: stringScalarAlias,
   Slot: bigIntScalarAlias,
   TokenBalance: {
@@ -1588,12 +1890,7 @@ var typeTypeResolvers = {
   },
   TransactionEncoding: {
     BASE_58: "base58",
-    BASE_64: "base64",
-    PARSED: "jsonParsed"
-  },
-  TransactionVersion: {
-    LEGACY: "legacy",
-    ZERO: 0
+    BASE_64: "base64"
   }
 };
 
@@ -1797,93 +2094,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
+    A Solana block
     """
-    type BlockWithAccounts implements Block {
+    type Block {
         blockhash: String
         blockHeight: BigInt
         blockTime: BigInt
-        parentSlot: BigInt
-        previousBlockhash: String
-        rewards: [Reward]
-        transactions: [BlockTransactionAccounts]
-        transactionDetails: String
-    }
-
-    """
-    A block with full transaction details
-    """
-    type BlockWithFull implements 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
     }
 `
 );
@@ -2005,12 +2227,12 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         bufferAccount: Account
-        clockSysvar: Address
+        clockSysvar: Account
         maxDataLen: BigInt
         payerAccount: Account
         programAccount: Account
         programDataAccount: Account
-        rentSysvar: Address
+        rentSysvar: Account
     }
 
     """
@@ -2020,10 +2242,10 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         bufferAccount: Account
-        clockSysvar: Address
+        clockSysvar: Account
         programAccount: Account
         programDataAccount: Account
-        rentSysvar: Address
+        rentSysvar: Account
         spillAccount: Account
     }
 
@@ -2076,7 +2298,7 @@ var instructionTypeDefs = (
     type SplAssociatedTokenCreateInstruction implements TransactionInstruction {
         programId: Address
         account: Account
-        mint: Address
+        mint: Account
         source: Account
         systemProgram: Account
         tokenProgram: Account
@@ -2089,7 +2311,7 @@ var instructionTypeDefs = (
     type SplAssociatedTokenCreateIdempotentInstruction implements TransactionInstruction {
         programId: Address
         account: Account
-        mint: Address
+        mint: Account
         source: Account
         systemProgram: Account
         tokenProgram: Account
@@ -2127,7 +2349,7 @@ var instructionTypeDefs = (
         freezeAuthority: Account
         mint: Account
         mintAuthority: Account
-        rentSysvar: Address
+        rentSysvar: Account
     }
 
     """
@@ -2149,7 +2371,7 @@ var instructionTypeDefs = (
         account: Account
         mint: Account
         owner: Account
-        rentSysvar: Address
+        rentSysvar: Account
     }
 
     """
@@ -2160,7 +2382,7 @@ var instructionTypeDefs = (
         account: Account
         mint: Account
         owner: Account
-        rentSysvar: Address
+        rentSysvar: Account
     }
 
     """
@@ -2180,7 +2402,7 @@ var instructionTypeDefs = (
         programId: Address
         m: BigInt # FIXME:*
         multisig: Account
-        rentSysvar: Address
+        rentSysvar: Account
         signers: [Address]
     }
 
@@ -2435,7 +2657,7 @@ var instructionTypeDefs = (
         programId: Address
         authorized: StakeInitializeInstructionDataAuthorized
         lockup: Lockup
-        rentSysvar: Address
+        rentSysvar: Account
         stakeAccount: Account
     }
 
@@ -2446,7 +2668,7 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         custodian: Account
         newAuthority: Account
         stakeAccount: Account
@@ -2457,11 +2679,11 @@ var instructionTypeDefs = (
     """
     type StakeDelegateStakeInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
+        clockSysvar: Account
         stakeAccount: Account
         stakeAuthority: Account
         stakeConfigAccount: Account
-        stakeHistorySysvar: Address
+        stakeHistorySysvar: Account
         voteAccount: Account
     }
 
@@ -2481,7 +2703,7 @@ var instructionTypeDefs = (
     """
     type StakeWithdrawInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
+        clockSysvar: Account
         destination: Account
         lamports: BigInt
         stakeAccount: Account
@@ -2493,7 +2715,7 @@ var instructionTypeDefs = (
     """
     type StakeDeactivateInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
+        clockSysvar: Account
         stakeAccount: Account
         stakeAuthority: Account
     }
@@ -2513,11 +2735,11 @@ var instructionTypeDefs = (
     """
     type StakeMergeInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
+        clockSysvar: Account
         destination: Account
         source: Account
         stakeAuthority: Account
-        stakeHistorySysvar: Address
+        stakeHistorySysvar: Account
     }
 
     """
@@ -2529,7 +2751,7 @@ var instructionTypeDefs = (
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         custodian: Account
         newAuthorized: Account
         stakeAccount: Account
@@ -2546,7 +2768,7 @@ var instructionTypeDefs = (
         programId: Address
         authorized: StakeInitializeCheckedInstructionDataAuthorized
         lockup: Lockup
-        rentSysvar: Address
+        rentSysvar: Account
         stakeAccount: Account
     }
 
@@ -2557,7 +2779,7 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         custodian: Account
         newAuthority: Account
         stakeAccount: Account
@@ -2572,7 +2794,7 @@ var instructionTypeDefs = (
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         custodian: Account
         newAuthorized: Account
         stakeAccount: Account
@@ -2660,7 +2882,7 @@ var instructionTypeDefs = (
         programId: Address
         nonceAccount: Account
         nonceAuthority: Account
-        recentBlockhashesSysvar: Address
+        recentBlockhashesSysvar: Account
     }
 
     """
@@ -2672,8 +2894,8 @@ var instructionTypeDefs = (
         lamports: BigInt
         nonceAccount: Account
         nonceAuthority: Account
-        recentBlockhashesSysvar: Address
-        rentSysvar: Address
+        recentBlockhashesSysvar: Account
+        rentSysvar: Account
     }
 
     """
@@ -2683,8 +2905,8 @@ var instructionTypeDefs = (
         programId: Address
         nonceAccount: Account
         nonceAuthority: Account
-        recentBlockhashesSysvar: Address
-        rentSysvar: Address
+        recentBlockhashesSysvar: Account
+        rentSysvar: Account
     }
 
     """
@@ -2758,10 +2980,10 @@ var instructionTypeDefs = (
         programId: Address
         authorizedVoter: Account
         authorizedWithdrawer: Account
-        clockSysvar: Address
+        clockSysvar: Account
         commission: BigInt # FIXME:*
         node: Account
-        rentSysvar: Address
+        rentSysvar: Account
         voteAccount: Account
     }
 
@@ -2772,7 +2994,7 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         newAuthority: Account
         voteAccount: Account
     }
@@ -2786,7 +3008,7 @@ var instructionTypeDefs = (
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         newAuthority: Account
         voteAccount: Account
     }
@@ -2800,7 +3022,7 @@ var instructionTypeDefs = (
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         newAuthority: Account
         voteAccount: Account
     }
@@ -2816,8 +3038,8 @@ var instructionTypeDefs = (
     """
     type VoteVoteInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
-        slotHashesSysvar: Address
+        clockSysvar: Account
+        slotHashesSysvar: Account
         vote: Vote
         voteAccount: Account
         voteAuthority: Account
@@ -2914,9 +3136,9 @@ var instructionTypeDefs = (
     """
     type VoteVoteSwitchInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
+        clockSysvar: Account
         hash: String
-        slotHashesSysvar: Address
+        slotHashesSysvar: Account
         vote: Vote
         voteAccount: Account
         voteAuthority: Account
@@ -2929,7 +3151,7 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         newAuthority: Account
         voteAccount: Account
     }
@@ -2942,21 +3164,14 @@ 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
-            dataSlice: DataSlice
-            encoding: AccountEncoding
             filters: [ProgramAccountsFilter]
             minContextSlot: Slot
         ): [Account]
-        transaction(signature: Signature!, commitment: Commitment, encoding: TransactionEncoding): Transaction
+        transaction(signature: Signature!, commitment: CommitmentWithoutProcessed): Transaction
     }
 
     schema {
@@ -3031,49 +3246,15 @@ var transactionTypeDefs = (
     }
 
     """
-    Transaction interface
+    A Solana transaction
     """
-    interface Transaction {
+    type Transaction {
         blockTime: BigInt
-        meta: TransactionMeta
-        slot: BigInt
-        version: String
-    }
-
-    """
-    A transaction with base58 encoded data
-    """
-    type TransactionBase58 implements Transaction {
-        blockTime: BigInt
-        data: Base58EncodedBytes
-        meta: TransactionMeta
-        slot: BigInt
-        version: String
-    }
-
-    """
-    A transaction with base64 encoded data
-    """
-    type TransactionBase64 implements Transaction {
-        blockTime: BigInt
-        data: Base64EncodedBytes
-        meta: TransactionMeta
-        slot: BigInt
-        version: String
-    }
-
-    """
-    A transaction with JSON encoded data
-    """
-    type TransactionDataParsed {
+        data(encoding: TransactionEncoding!): String
         message: TransactionMessage
-        signatures: [String]
-    }
-    type TransactionParsed implements Transaction {
-        blockTime: BigInt
-        data: TransactionDataParsed
         meta: TransactionMeta
-        slot: BigInt
+        signatures: [Signature]
+        slot: Slot
         version: String
     }
 `
@@ -3099,19 +3280,17 @@ var typeTypeDefs = (
 
     scalar BigInt
 
-    enum BlockTransactionDetails {
-        ACCOUNTS
-        FULL
-        NONE
-        SIGNATURES
-    }
-
     enum Commitment {
         CONFIRMED
         FINALIZED
         PROCESSED
     }
 
+    enum CommitmentWithoutProcessed {
+        CONFIRMED
+        FINALIZED
+    }
+
     input DataSlice {
         offset: Int!
         length: Int!
@@ -3159,12 +3338,6 @@ var typeTypeDefs = (
     enum TransactionEncoding {
         BASE_58
         BASE_64
-        PARSED
-    }
-
-    enum TransactionVersion {
-        LEGACY
-        ZERO
     }
 `
 );