@solana/rpc-graphql 2.0.0-experimental.f8c941c → 2.0.0-experimental.fafdfb2

package/dist/index.node.cjs

@@ -2,6 +2,7 @@
 
 var schema = require('@graphql-tools/schema');
 var graphql = require('graphql');
+var codecsStrings = require('@solana/codecs-strings');
 var DataLoader = require('dataloader');
 var stringify = require('json-stable-stringify');
 
@@ -19,292 +20,779 @@ function replacer(_, value) {
 }
 var cacheKeyFn = (obj) => stringify__default.default(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 applyDefaultArgs({
-  address,
-  commitment,
-  dataSlice,
-  encoding = "jsonParsed",
-  minContextSlot
-}) {
-  return {
-    address,
-    commitment,
-    dataSlice,
-    encoding,
-    minContextSlot
-  };
+function getCodec(encoding) {
+  switch (encoding) {
+    case "base58":
+      return codecsStrings.getBase58Codec();
+    default:
+      return codecsStrings.getBase64Codec();
+  }
+}
+function sliceData(account, dataSlice, masterDataSlice) {
+  if (dataSlice) {
+    const masterOffset = masterDataSlice ? masterDataSlice.offset : 0;
+    const slicedData = (data, encoding) => {
+      if (encoding === "base64+zstd") {
+        return data;
+      }
+      const { offset, length } = dataSlice;
+      const trueOffset = offset - masterOffset;
+      const codec = getCodec(encoding);
+      return codec.decode(codec.encode(data).slice(trueOffset, trueOffset + length));
+    };
+    if (Array.isArray(account.data)) {
+      const [data, encoding] = account.data;
+      return {
+        ...account,
+        data: [slicedData(data, encoding), encoding]
+      };
+    } else if (typeof account.data === "string") {
+      const data = account.data;
+      return {
+        ...account,
+        data: slicedData(data, "base58")
+      };
+    }
+  }
+  return account;
 }
 async function loadAccount(rpc, { address, ...config }) {
   return await rpc.getAccountInfo(address, config).send().then((res) => res.value);
 }
-function createAccountBatchLoadFn(rpc) {
+async function loadMultipleAccounts(rpc, { addresses, ...config }) {
+  return await rpc.getMultipleAccounts(addresses, config).send().then((res) => res.value);
+}
+function createAccountBatchLoadFn(rpc, config) {
   const resolveAccountUsingRpc = loadAccount.bind(null, rpc);
+  const resolveMultipleAccountsUsingRpc = loadMultipleAccounts.bind(null, rpc);
   return async (accountQueryArgs) => {
-    return await Promise.all(
-      accountQueryArgs.map(async (args) => await resolveAccountUsingRpc(applyDefaultArgs(args)))
-    );
-  };
-}
-function createAccountLoader(rpc) {
-  const loader = new DataLoader__default.default(createAccountBatchLoadFn(rpc), { cacheKeyFn });
-  return {
-    load: async (args) => loader.load(applyDefaultArgs(args))
+    const accountsToFetch = {};
+    try {
+      return Promise.all(
+        accountQueryArgs.map(
+          ({ address, ...args }) => new Promise((resolve, reject) => {
+            const accountRecords = accountsToFetch[address] ||= [];
+            if (!args.commitment) {
+              args.commitment = "confirmed";
+            }
+            accountRecords.push({ args, promiseCallback: { reject, resolve } });
+          })
+        )
+      );
+    } finally {
+      const { maxDataSliceByteRange, maxMultipleAccountsBatchSize } = config;
+      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];
+          return Array.from({ length: 1 }, async () => {
+            try {
+              const result = await resolveAccountUsingRpc({ address, ...args });
+              addressCallbacks[address].callbacks.forEach(({ callback, dataSlice }) => {
+                callback.resolve(sliceData(result, dataSlice, args.dataSlice));
+              });
+            } catch (e) {
+              addressCallbacks[address].callbacks.forEach(({ callback }) => {
+                callback.reject(e);
+              });
+            }
+          });
+        } else {
+          return Array.from(
+            { length: Math.ceil(addresses.length / maxMultipleAccountsBatchSize) },
+            async (_, ii) => {
+              const startIndex = ii * maxMultipleAccountsBatchSize;
+              const endIndex = startIndex + maxMultipleAccountsBatchSize;
+              const chunk = addresses.slice(startIndex, endIndex);
+              try {
+                const results = await resolveMultipleAccountsUsingRpc({
+                  addresses: chunk,
+                  ...args
+                });
+                chunk.forEach((address, ii2) => {
+                  const result = results[ii2];
+                  addressCallbacks[address].callbacks.forEach(({ callback, dataSlice }) => {
+                    callback.resolve(sliceData(result, dataSlice, args.dataSlice));
+                  });
+                });
+              } catch (e) {
+                chunk.forEach((address) => {
+                  addressCallbacks[address].callbacks.forEach(({ callback }) => {
+                    callback.reject(e);
+                  });
+                });
+              }
+            }
+          );
+        }
+      });
+    }
   };
 }
-function applyDefaultArgs2({
-  slot,
-  commitment,
-  encoding = "jsonParsed",
-  maxSupportedTransactionVersion = 0,
-  rewards,
-  transactionDetails = "full"
-}) {
+function createAccountLoader(rpc, config) {
+  const loader = new DataLoader__default.default(createAccountBatchLoadFn(rpc, config), { cacheKeyFn });
   return {
-    commitment,
-    encoding,
-    maxSupportedTransactionVersion,
-    rewards,
-    slot,
-    transactionDetails
+    load: async (args) => loader.load(args),
+    loadMany: async (args) => loader.loadMany(args)
   };
 }
 async function loadBlock(rpc, { slot, ...config }) {
   return await rpc.getBlock(
     slot,
-    // @ts-expect-error FIX ME: https://github.com/solana-labs/solana-web3.js/pull/2052
+    // @ts-expect-error FIX ME: https://github.com/microsoft/TypeScript/issues/43187
     config
   ).send();
 }
 function createBlockBatchLoadFn(rpc) {
   const resolveBlockUsingRpc = loadBlock.bind(null, rpc);
   return async (blockQueryArgs) => {
-    return await Promise.all(blockQueryArgs.map(async (args) => await resolveBlockUsingRpc(applyDefaultArgs2(args))));
+    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(applyDefaultArgs2(args))
-  };
-}
-function applyDefaultArgs3({
-  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 }) {
   return await rpc.getProgramAccounts(
     programAddress,
-    // @ts-expect-error FIX ME: https://github.com/solana-labs/solana-web3.js/pull/2052
+    // @ts-expect-error FIX ME: https://github.com/microsoft/TypeScript/issues/43187
     config
   ).send();
 }
-function createProgramAccountsBatchLoadFn(rpc) {
+function createProgramAccountsBatchLoadFn(rpc, config) {
   const resolveProgramAccountsUsingRpc = loadProgramAccounts.bind(null, rpc);
-  return async (programAccountsQueryArgs) => {
-    return await Promise.all(
-      programAccountsQueryArgs.map(async (args) => await resolveProgramAccountsUsingRpc(applyDefaultArgs3(args)))
-    );
-  };
-}
-function createProgramAccountsLoader(rpc) {
-  const loader = new DataLoader__default.default(createProgramAccountsBatchLoadFn(rpc), { cacheKeyFn });
-  return {
-    load: async (args) => loader.load(applyDefaultArgs3(args))
+  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 applyDefaultArgs4({
-  commitment,
-  encoding = "jsonParsed",
-  signature
-}) {
+function createProgramAccountsLoader(rpc, config) {
+  const loader = new DataLoader__default.default(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 }) {
   return await rpc.getTransaction(
     signature,
-    // @ts-expect-error FIX ME: https://github.com/solana-labs/solana-web3.js/pull/2052
+    // @ts-expect-error FIX ME: https://github.com/microsoft/TypeScript/issues/43187
     config
   ).send();
 }
 function createTransactionBatchLoadFn(rpc) {
   const resolveTransactionUsingRpc = loadTransaction.bind(null, rpc);
   return async (transactionQueryArgs) => {
-    return await Promise.all(
-      transactionQueryArgs.map(async (args) => await resolveTransactionUsingRpc(applyDefaultArgs4(args)))
-    );
+    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__default.default(createTransactionBatchLoadFn(rpc), { cacheKeyFn });
   return {
-    load: async (args) => loader.load(applyDefaultArgs4(args))
+    load: async (args) => loader.load(args),
+    loadMany: async (args) => loader.loadMany(args)
   };
 }
 
 // src/context.ts
-function createSolanaGraphQLContext(rpc) {
+function createSolanaGraphQLContext(rpc, config) {
   return {
     loaders: {
-      account: createAccountLoader(rpc),
+      account: createAccountLoader(rpc, config),
       block: createBlockLoader(rpc),
-      programAccounts: createProgramAccountsLoader(rpc),
+      programAccounts: createProgramAccountsLoader(rpc, config),
       transaction: createTransactionLoader(rpc)
-    },
-    rpc
+    }
   };
 }
-
-// src/resolvers/resolve-info.ts
-function onlyPresentFieldRequested(fieldName, info) {
-  if (info && info.fieldNodes[0].selectionSet) {
-    const selectionSet = info.fieldNodes[0].selectionSet;
-    const requestedFields = selectionSet.selections.map((field) => {
-      if (field.kind === "Field") {
-        return field.name.value;
+function injectableRootVisitor(info, rootNode, operations) {
+  const { fieldNodes } = info;
+  const root = rootNode ?? fieldNodes[0];
+  const parentIsRoot = (ancestors) => (Array.isArray(ancestors) ? ancestors[0] : ancestors) === root;
+  graphql.visit(root, {
+    Field(node, key, parent, path, ancestors) {
+      if (!parentIsRoot(ancestors))
+        return;
+      return operations.fieldNodeOperation(info, node, key, parent, path, ancestors);
+    },
+    FragmentSpread(node, key, parent, path, ancestors) {
+      const fragmentDefinition = info.fragments[node.name.value];
+      return operations.fragmentSpreadNodeOperation(info, fragmentDefinition, node, key, parent, path, ancestors);
+    },
+    InlineFragment(node, key, parent, path, ancestors) {
+      if (!parentIsRoot(ancestors))
+        return;
+      return operations.inlineFragmentNodeOperation(info, node, key, parent, path, ancestors);
+    }
+  });
+}
+function onlyFieldsRequested(fieldNames, info, rootNode) {
+  let onlyFieldsRequested2 = true;
+  function checkFieldsWithVisitor(root) {
+    injectableRootVisitor(info, root, {
+      fieldNodeOperation(_info, node) {
+        onlyFieldsRequested2 = fieldNames.includes(node.name.value);
+        if (!onlyFieldsRequested2) {
+          return graphql.BREAK;
+        }
+      },
+      fragmentSpreadNodeOperation(_info, fragment) {
+        checkFieldsWithVisitor(fragment);
+      },
+      inlineFragmentNodeOperation(_info, node) {
+        checkFieldsWithVisitor(node);
       }
-      return null;
     });
-    if (requestedFields && requestedFields.length === 1 && requestedFields[0] === fieldName) {
-      return true;
-    }
   }
-  return false;
+  checkFieldsWithVisitor(rootNode ?? null);
+  return onlyFieldsRequested2;
 }
 
-// src/resolvers/account.ts
-function transformParsedAccountData(parsedAccountData) {
-  const {
-    parsed: { info: result, type: accountType },
-    program: programName,
-    programId
-  } = parsedAccountData;
-  result.accountType = accountType;
-  result.programId = programId;
-  result.programName = programName;
-  return result;
-}
-function transformLoadedAccount({
-  account,
-  address,
-  encoding = "jsonParsed"
-}) {
-  const [
-    // The account's data, either encoded or parsed.
-    data,
-    // Tells GraphQL which encoding has been returned
-    // by the RPC.
-    responseEncoding
-  ] = Array.isArray(account.data) ? encoding === "jsonParsed" ? (
-    // The requested encoding is jsonParsed,
-    // but the data could not be parsed.
-    // Defaults to base64 encoding.
-    [{ data: account.data[0] }, "base64"]
-  ) : (
-    // The requested encoding is base58,
-    // base64, or base64+zstd.
-    [{ data: account.data[0] }, encoding]
-  ) : (
-    // The account data was returned as an object,
-    // so it was parsed successfully.
-    [transformParsedAccountData(account.data), "jsonParsed"]
-  );
-  account.address = address;
-  account.encoding = responseEncoding;
-  account.ownerProgram = account.owner;
-  return {
-    ...account,
-    ...data
-  };
+// src/resolvers/resolve-info/account.ts
+function findArgumentNodeByName(argumentNodes, name) {
+  return argumentNodes.find((argumentNode) => argumentNode.name.value === name);
 }
-var resolveAccount = (fieldName) => {
-  return async (parent, args, context, info) => {
-    const address = fieldName ? parent[fieldName] : args.address;
-    if (!address) {
-      return null;
+function parseAccountEncodingArgument(argumentNodes, variableValues) {
+  const argumentNode = findArgumentNodeByName(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.value === "BASE_64_ZSTD") {
+        return "base64+zstd";
+      }
     }
-    if (onlyPresentFieldRequested("address", info)) {
-      return { address };
+    if (argumentNode.value.kind === "Variable") {
+      return variableValues[argumentNode.value.name.value];
     }
-    const account = await context.loaders.account.load({ ...args, address });
-    return account === null ? { address } : transformLoadedAccount({ account, address, encoding: args.encoding });
-  };
-};
-var accountResolvers = {
-  Account: {
-    __resolveType(account) {
-      if (account.encoding === "base58") {
-        return "AccountBase58";
+  } else {
+    return void 0;
+  }
+}
+function parseAccountDataSliceArgument(argumentNodes, variableValues) {
+  const argumentNode = findArgumentNodeByName(argumentNodes, "dataSlice");
+  if (argumentNode) {
+    if (argumentNode.value.kind === "ObjectValue") {
+      const offsetArg = argumentNode.value.fields?.find((field) => field.name.value === "offset");
+      const lengthArg = argumentNode.value.fields?.find((field) => field.name.value === "length");
+      const length = lengthArg?.value.kind === "IntValue" ? parseInt(lengthArg.value.value) : lengthArg?.value.kind === "Variable" ? variableValues[lengthArg.value.name.value] : void 0;
+      const offset = offsetArg?.value.kind === "IntValue" ? parseInt(offsetArg.value.value) : offsetArg?.value.kind === "Variable" ? variableValues[offsetArg.value.name.value] : void 0;
+      return length !== void 0 && length !== null && offset !== void 0 && offset !== null ? { length, offset } : void 0;
+    }
+    if (argumentNode.value.kind === "Variable") {
+      return variableValues[argumentNode.value.name.value];
+    }
+  } else {
+    return void 0;
+  }
+}
+function buildAccountArgSetWithVisitor(args, info) {
+  const argSet = [args];
+  function buildArgSetWithVisitor(root) {
+    injectableRootVisitor(info, root, {
+      fieldNodeOperation(info2, node) {
+        if (node.name.value !== "data") {
+          return;
+        }
+        if (node.arguments) {
+          const { variableValues } = info2;
+          const encoding = parseAccountEncodingArgument(node.arguments, variableValues);
+          const dataSlice = parseAccountDataSliceArgument(node.arguments, variableValues);
+          argSet.push({ ...args, dataSlice, encoding });
+        }
+      },
+      fragmentSpreadNodeOperation(_info, fragment) {
+        buildArgSetWithVisitor(fragment);
+      },
+      inlineFragmentNodeOperation(info2, node) {
+        const { schema } = info2;
+        const accountInterface = schema.getType("Account");
+        if (graphql.isInterfaceType(accountInterface) && // Recursively check if the inline fragment requests any
+        // fields outside of the `Account` interface.
+        !onlyFieldsRequested(Object.keys(accountInterface.getFields()), info2, node)) {
+          argSet.push({ ...args, encoding: "jsonParsed" });
+        }
       }
-      if (account.encoding === "base64") {
-        return "AccountBase64";
+    });
+  }
+  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 (account.encoding === "base64+zstd") {
-        return "AccountBase64Zstd";
+      if (argumentNode.value.value === "BASE_64") {
+        return "base64";
       }
-      if (account.encoding === "jsonParsed") {
-        if (account.programName === "nonce") {
-          return "NonceAccount";
+    }
+    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 });
+          }
         }
-        if (account.accountType === "mint" && account.programName === "spl-token") {
-          return "MintAccount";
+      },
+      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));
         }
-        if (account.accountType === "account" && account.programName === "spl-token") {
-          return "TokenAccount";
+      },
+      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 = () => {
+  return (parent, args) => {
+    return parent === null ? null : parent.encodedData ? parent.encodedData[cacheKeyFn(args)] : null;
+  };
+};
+var resolveAccount = (fieldName) => {
+  return async (parent, args, context, info) => {
+    const address = fieldName ? parent[fieldName] : args.address;
+    if (address) {
+      if (onlyFieldsRequested(["address"], info)) {
+        return { address };
+      }
+      const argsSet = buildAccountLoaderArgSetFromResolveInfo({ ...args, address }, info);
+      const loadedAccounts = await context.loaders.account.loadMany(argsSet);
+      let result = {
+        address,
+        encodedData: {}
+      };
+      loadedAccounts.forEach((account, i) => {
+        if (account instanceof Error) {
+          console.error(account);
+          return;
         }
-        if (account.programName === "stake") {
-          return "StakeAccount";
+        if (account === null) {
+          return;
         }
-        if (account.accountType === "vote" && account.programName === "vote") {
-          return "VoteAccount";
+        if (!result.ownerProgram) {
+          result = {
+            ...result,
+            ...account,
+            ownerProgram: account.owner
+          };
         }
-        if (account.accountType === "lookupTable" && account.programName === "address-lookup-table") {
-          return "LookupTableAccount";
+        const { data } = account;
+        const { encoding, dataSlice } = argsSet[i];
+        if (encoding && result.encodedData) {
+          if (Array.isArray(data)) {
+            result.encodedData[cacheKeyFn({
+              dataSlice,
+              encoding: encoding === "jsonParsed" ? "base64" : encoding
+            })] = 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
+            };
+          }
         }
-      }
-      return "AccountBase64";
+      });
+      return result;
     }
+    return null;
+  };
+};
+function resolveAccountType(accountResult) {
+  const { jsonParsedConfigs } = accountResult;
+  if (jsonParsedConfigs) {
+    if (jsonParsedConfigs.programName === "nonce") {
+      return "NonceAccount";
+    }
+    if (jsonParsedConfigs.accountType === "mint" && jsonParsedConfigs.programName === "spl-token") {
+      return "MintAccount";
+    }
+    if (jsonParsedConfigs.accountType === "account" && jsonParsedConfigs.programName === "spl-token") {
+      return "TokenAccount";
+    }
+    if (jsonParsedConfigs.programName === "stake") {
+      return "StakeAccount";
+    }
+    if (jsonParsedConfigs.accountType === "vote" && jsonParsedConfigs.programName === "vote") {
+      return "VoteAccount";
+    }
+    if (jsonParsedConfigs.accountType === "lookupTable" && jsonParsedConfigs.programName === "address-lookup-table") {
+      return "LookupTableAccount";
+    }
+  }
+  return "GenericAccount";
+}
+var accountResolvers = {
+  Account: {
+    __resolveType: resolveAccountType,
+    data: resolveAccountData()
   },
-  AccountBase58: {
-    ownerProgram: resolveAccount("ownerProgram")
-  },
-  AccountBase64: {
-    ownerProgram: resolveAccount("ownerProgram")
-  },
-  AccountBase64Zstd: {
+  GenericAccount: {
+    data: resolveAccountData(),
     ownerProgram: resolveAccount("ownerProgram")
   },
   LookupTableAccount: {
     authority: resolveAccount("authority"),
+    data: resolveAccountData(),
     ownerProgram: resolveAccount("ownerProgram")
   },
   MintAccount: {
+    data: resolveAccountData(),
     freezeAuthority: resolveAccount("freezeAuthority"),
     mintAuthority: resolveAccount("mintAuthority"),
     ownerProgram: resolveAccount("ownerProgram")
   },
   NonceAccount: {
     authority: resolveAccount("authority"),
+    data: resolveAccountData(),
     ownerProgram: resolveAccount("ownerProgram")
   },
   StakeAccount: {
+    data: resolveAccountData(),
     ownerProgram: resolveAccount("ownerProgram")
   },
   StakeAccountDataMetaAuthorized: {
@@ -318,12 +806,14 @@ var accountResolvers = {
     voter: resolveAccount("voter")
   },
   TokenAccount: {
+    data: resolveAccountData(),
     mint: resolveAccount("mint"),
     owner: resolveAccount("owner"),
     ownerProgram: resolveAccount("ownerProgram")
   },
   VoteAccount: {
     authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
+    data: resolveAccountData(),
     node: resolveAccount("nodePubkey"),
     ownerProgram: resolveAccount("ownerProgram")
   },
@@ -333,147 +823,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 (onlyPresentFieldRequested("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 (onlyPresentFieldRequested("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
   }
 };
 
@@ -481,7 +1031,8 @@ var blockResolvers = {
 var instructionResolvers = {
   AdvanceNonceAccountInstruction: {
     nonceAccount: resolveAccount("nonceAccount"),
-    nonceAuthority: resolveAccount("nonceAuthority")
+    nonceAuthority: resolveAccount("nonceAuthority"),
+    recentBlockhashesSysvar: resolveAccount("recentBlockhashesSysvar")
   },
   AllocateInstruction: {
     account: resolveAccount("account")
@@ -518,9 +1069,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"),
@@ -544,8 +1097,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"),
@@ -588,7 +1143,9 @@ var instructionResolvers = {
   },
   InitializeNonceAccountInstruction: {
     nonceAccount: resolveAccount("nonceAccount"),
-    nonceAuthority: resolveAccount("nonceAuthority")
+    nonceAuthority: resolveAccount("nonceAuthority"),
+    recentBlockhashesSysvar: resolveAccount("recentBlockhashesSysvar"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   Lockup: {
     custodian: resolveAccount("custodian")
@@ -664,7 +1221,8 @@ var instructionResolvers = {
   SplTokenInitializeAccount2Instruction: {
     account: resolveAccount("account"),
     mint: resolveAccount("mint"),
-    owner: resolveAccount("owner")
+    owner: resolveAccount("owner"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   SplTokenInitializeAccount3Instruction: {
     account: resolveAccount("account"),
@@ -674,7 +1232,8 @@ var instructionResolvers = {
   SplTokenInitializeAccountInstruction: {
     account: resolveAccount("account"),
     mint: resolveAccount("mint"),
-    owner: resolveAccount("owner")
+    owner: resolveAccount("owner"),
+    rentSysvar: resolveAccount("rentSysvar")
   },
   SplTokenInitializeMint2Instruction: {
     freezeAuthority: resolveAccount("freezeAuthority"),
@@ -688,13 +1247,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"),
@@ -747,6 +1308,7 @@ var instructionResolvers = {
   },
   StakeAuthorizeCheckedInstruction: {
     authority: resolveAccount("authority"),
+    clockSysvar: resolveAccount("clockSysvar"),
     custodian: resolveAccount("custodian"),
     newAuthority: resolveAccount("newAuthority"),
     stakeAccount: resolveAccount("stakeAccount")
@@ -754,12 +1316,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")
@@ -767,6 +1331,7 @@ var instructionResolvers = {
   StakeAuthorizeWithSeedInstruction: {
     authorityBase: resolveAccount("authorityBase"),
     authorityOwner: resolveAccount("authorityOwner"),
+    clockSysvar: resolveAccount("clockSysvar"),
     custodian: resolveAccount("custodian"),
     newAuthorized: resolveAccount("newAuthorized"),
     stakeAccount: resolveAccount("stakeAccount")
@@ -777,20 +1342,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: {
@@ -798,9 +1371,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"),
@@ -823,287 +1398,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";
           }
         }
@@ -1126,21 +1703,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")
   },
@@ -1155,7 +1736,9 @@ var instructionResolvers = {
   VoteInitializeAccountInstruction: {
     authorizedVoter: resolveAccount("authorizedVoter"),
     authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
+    clockSysvar: resolveAccount("clockSysvar"),
     node: resolveAccount("node"),
+    rentSysvar: resolveAccount("rentSysvar"),
     voteAccount: resolveAccount("voteAccount")
   },
   VoteUpdateCommissionInstruction: {
@@ -1176,10 +1759,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")
   },
@@ -1190,7 +1777,9 @@ var instructionResolvers = {
   WithdrawNonceAccountInstruction: {
     destination: resolveAccount("destination"),
     nonceAccount: resolveAccount("nonceAccount"),
-    nonceAuthority: resolveAccount("nonceAuthority")
+    nonceAuthority: resolveAccount("nonceAuthority"),
+    recentBlockhashesSysvar: resolveAccount("recentBlockhashesSysvar"),
+    rentSysvar: resolveAccount("rentSysvar")
   }
 };
 
@@ -1198,20 +1787,57 @@ var instructionResolvers = {
 function resolveProgramAccounts(fieldName) {
   return async (parent, args, context, info) => {
     const programAddress = fieldName ? parent[fieldName] : args.programAddress;
-    if (!programAddress) {
-      return null;
-    }
-    if (onlyPresentFieldRequested("programAddress", info)) {
-      return { programAddress };
-    }
-    const programAccounts = await context.loaders.programAccounts.load({ ...args, programAddress });
-    return programAccounts === null ? { programAddress } : programAccounts.map(
-      (programAccount) => transformLoadedAccount({
-        account: programAccount.account,
-        address: programAccount.pubkey,
-        encoding: args.encoding
-      })
-    );
+    if (programAddress) {
+      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;
+        }
+        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;
   };
 }
 
@@ -1238,47 +1864,49 @@ var stringScalarAlias = {
     return value;
   }
 };
-var scalarResolvers = {
-  Address: stringScalarAlias,
-  Base58EncodedBytes: stringScalarAlias,
-  Base64EncodedBytes: stringScalarAlias,
-  Base64ZstdEncodedBytes: stringScalarAlias,
-  BigInt: {
-    __parseLiteral(ast) {
-      if (ast.kind === graphql.Kind.STRING) {
-        return BigInt(ast.value);
-      }
-      return null;
-    },
-    __parseValue(value) {
-      return BigInt(value);
-    },
-    __serialize(value) {
-      return BigInt(value);
+var bigIntScalarAlias = {
+  __parseLiteral(ast) {
+    if (ast.kind === graphql.Kind.STRING || ast.kind === graphql.Kind.INT || ast.kind === graphql.Kind.FLOAT) {
+      return BigInt(ast.value);
     }
+    return null;
+  },
+  __parseValue(value) {
+    return BigInt(value);
+  },
+  __serialize(value) {
+    return BigInt(value);
   }
 };
-
-// src/resolvers/types.ts
-var commonTypeResolvers = {
+var typeTypeResolvers = {
   AccountEncoding: {
     BASE_58: "base58",
     BASE_64: "base64",
-    BASE_64_ZSTD: "base64+zstd",
-    PARSED: "jsonParsed"
+    BASE_64_ZSTD: "base64+zstd"
   },
+  Address: stringScalarAlias,
+  Base58EncodedBytes: stringScalarAlias,
+  Base64EncodedBytes: stringScalarAlias,
+  Base64ZstdEncodedBytes: stringScalarAlias,
+  BigInt: bigIntScalarAlias,
+  Commitment: {
+    CONFIRMED: "confirmed",
+    FINALIZED: "finalized",
+    PROCESSED: "processed"
+  },
+  CommitmentWithoutProcessed: {
+    CONFIRMED: "confirmed",
+    FINALIZED: "finalized"
+  },
+  Signature: stringScalarAlias,
+  Slot: bigIntScalarAlias,
   TokenBalance: {
     mint: resolveAccount("mint"),
     owner: resolveAccount("owner")
   },
   TransactionEncoding: {
     BASE_58: "base58",
-    BASE_64: "base64",
-    PARSED: "jsonParsed"
-  },
-  TransactionVersion: {
-    LEGACY: "legacy",
-    ZERO: 0
+    BASE_64: "base64"
   }
 };
 
@@ -1287,11 +1915,10 @@ function createSolanaGraphQLResolvers() {
   return {
     ...accountResolvers,
     ...blockResolvers,
-    ...commonTypeResolvers,
     ...instructionResolvers,
     ...rootResolvers,
-    ...scalarResolvers,
-    ...transactionResolvers
+    ...transactionResolvers,
+    ...typeTypeResolvers
   };
 }
 
@@ -1304,6 +1931,7 @@ var accountTypeDefs = (
     """
     interface Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1312,37 +1940,11 @@ var accountTypeDefs = (
     }
 
     """
-    An account with base58 encoded data
+    Generic base account type
     """
-    type AccountBase58 implements Account {
+    type GenericAccount implements Account {
         address: Address
-        data: Base58EncodedBytes
-        executable: Boolean
-        lamports: BigInt
-        ownerProgram: Account
-        space: BigInt
-        rentEpoch: BigInt
-    }
-
-    """
-    An account with base64 encoded data
-    """
-    type AccountBase64 implements Account {
-        address: Address
-        data: Base64EncodedBytes
-        executable: Boolean
-        lamports: BigInt
-        ownerProgram: Account
-        space: BigInt
-        rentEpoch: BigInt
-    }
-
-    """
-    An account with base64+zstd encoded data
-    """
-    type AccountBase64Zstd implements Account {
-        address: Address
-        data: Base64ZstdEncodedBytes
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1358,6 +1960,7 @@ var accountTypeDefs = (
     """
     type NonceAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1373,6 +1976,7 @@ var accountTypeDefs = (
     """
     type LookupTableAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1390,6 +1994,7 @@ var accountTypeDefs = (
     """
     type MintAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1407,6 +2012,7 @@ var accountTypeDefs = (
     """
     type TokenAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1449,6 +2055,7 @@ var accountTypeDefs = (
     """
     type StakeAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1480,6 +2087,7 @@ var accountTypeDefs = (
     """
     type VoteAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1502,188 +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
+    A Solana block
     """
-    interface Block {
+    type 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
-    """
-    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
-    }
-`
-);
-
-// src/schema/common/inputs.ts
-var inputTypeDefs = (
-  /* GraphQL */
-  `
-    input DataSlice {
-        offset: Int
-        length: Int
-    }
-
-    input ProgramAccountsFilter {
-        bytes: BigInt
-        dataSize: BigInt
-        encoding: AccountEncoding
-        offset: BigInt
-    }
-`
-);
-
-// src/schema/common/scalars.ts
-var scalarTypeDefs = (
-  /* GraphQL */
-  `
-    scalar Address
-    scalar Base58EncodedBytes
-    scalar Base64EncodedBytes
-    scalar Base64ZstdEncodedBytes
-    scalar BigInt
-`
-);
-
-// src/schema/common/types.ts
-var commonTypeDefs = (
-  /* GraphQL */
-  `
-    enum AccountEncoding {
-        BASE_58
-        BASE_64
-        BASE_64_ZSTD
-        PARSED
-    }
-
-    enum BlockTransactionDetails {
-        accounts
-        full
-        none
-        signatures
-    }
-
-    enum Commitment {
-        confirmed
-        finalized
-        processed
-    }
-
-    type ReturnData {
-        data: Base64EncodedBytes
-        programId: Address
-    }
-
-    type Reward {
-        commission: Int
-        lamports: BigInt
-        postBalance: BigInt
-        pubkey: Address
-        rewardType: String
-    }
-
-    type TokenAmount {
-        amount: String
-        decimals: Int
-        uiAmount: BigInt
-        uiAmountString: String
-    }
-
-    type TokenBalance {
-        accountIndex: Int
-        mint: Account
-        owner: Account
-        programId: Address
-        uiTokenAmount: TokenAmount
-    }
-
-    enum TransactionEncoding {
-        BASE_58
-        BASE_64
-        PARSED
-    }
-
-    enum TransactionVersion {
-        LEGACY
-        ZERO
     }
 `
 );
@@ -1805,12 +2243,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
     }
 
     """
@@ -1820,10 +2258,10 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         bufferAccount: Account
-        clockSysvar: Address
+        clockSysvar: Account
         programAccount: Account
         programDataAccount: Account
-        rentSysvar: Address
+        rentSysvar: Account
         spillAccount: Account
     }
 
@@ -1876,7 +2314,7 @@ var instructionTypeDefs = (
     type SplAssociatedTokenCreateInstruction implements TransactionInstruction {
         programId: Address
         account: Account
-        mint: Address
+        mint: Account
         source: Account
         systemProgram: Account
         tokenProgram: Account
@@ -1889,7 +2327,7 @@ var instructionTypeDefs = (
     type SplAssociatedTokenCreateIdempotentInstruction implements TransactionInstruction {
         programId: Address
         account: Account
-        mint: Address
+        mint: Account
         source: Account
         systemProgram: Account
         tokenProgram: Account
@@ -1927,7 +2365,7 @@ var instructionTypeDefs = (
         freezeAuthority: Account
         mint: Account
         mintAuthority: Account
-        rentSysvar: Address
+        rentSysvar: Account
     }
 
     """
@@ -1949,7 +2387,7 @@ var instructionTypeDefs = (
         account: Account
         mint: Account
         owner: Account
-        rentSysvar: Address
+        rentSysvar: Account
     }
 
     """
@@ -1960,7 +2398,7 @@ var instructionTypeDefs = (
         account: Account
         mint: Account
         owner: Account
-        rentSysvar: Address
+        rentSysvar: Account
     }
 
     """
@@ -1980,7 +2418,7 @@ var instructionTypeDefs = (
         programId: Address
         m: BigInt # FIXME:*
         multisig: Account
-        rentSysvar: Address
+        rentSysvar: Account
         signers: [Address]
     }
 
@@ -2235,7 +2673,7 @@ var instructionTypeDefs = (
         programId: Address
         authorized: StakeInitializeInstructionDataAuthorized
         lockup: Lockup
-        rentSysvar: Address
+        rentSysvar: Account
         stakeAccount: Account
     }
 
@@ -2246,7 +2684,7 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         custodian: Account
         newAuthority: Account
         stakeAccount: Account
@@ -2257,11 +2695,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
     }
 
@@ -2281,7 +2719,7 @@ var instructionTypeDefs = (
     """
     type StakeWithdrawInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
+        clockSysvar: Account
         destination: Account
         lamports: BigInt
         stakeAccount: Account
@@ -2293,7 +2731,7 @@ var instructionTypeDefs = (
     """
     type StakeDeactivateInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
+        clockSysvar: Account
         stakeAccount: Account
         stakeAuthority: Account
     }
@@ -2313,11 +2751,11 @@ var instructionTypeDefs = (
     """
     type StakeMergeInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
+        clockSysvar: Account
         destination: Account
         source: Account
         stakeAuthority: Account
-        stakeHistorySysvar: Address
+        stakeHistorySysvar: Account
     }
 
     """
@@ -2329,7 +2767,7 @@ var instructionTypeDefs = (
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         custodian: Account
         newAuthorized: Account
         stakeAccount: Account
@@ -2346,7 +2784,7 @@ var instructionTypeDefs = (
         programId: Address
         authorized: StakeInitializeCheckedInstructionDataAuthorized
         lockup: Lockup
-        rentSysvar: Address
+        rentSysvar: Account
         stakeAccount: Account
     }
 
@@ -2357,7 +2795,7 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         custodian: Account
         newAuthority: Account
         stakeAccount: Account
@@ -2372,7 +2810,7 @@ var instructionTypeDefs = (
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         custodian: Account
         newAuthorized: Account
         stakeAccount: Account
@@ -2460,7 +2898,7 @@ var instructionTypeDefs = (
         programId: Address
         nonceAccount: Account
         nonceAuthority: Account
-        recentBlockhashesSysvar: Address
+        recentBlockhashesSysvar: Account
     }
 
     """
@@ -2472,8 +2910,8 @@ var instructionTypeDefs = (
         lamports: BigInt
         nonceAccount: Account
         nonceAuthority: Account
-        recentBlockhashesSysvar: Address
-        rentSysvar: Address
+        recentBlockhashesSysvar: Account
+        rentSysvar: Account
     }
 
     """
@@ -2483,8 +2921,8 @@ var instructionTypeDefs = (
         programId: Address
         nonceAccount: Account
         nonceAuthority: Account
-        recentBlockhashesSysvar: Address
-        rentSysvar: Address
+        recentBlockhashesSysvar: Account
+        rentSysvar: Account
     }
 
     """
@@ -2558,10 +2996,10 @@ var instructionTypeDefs = (
         programId: Address
         authorizedVoter: Account
         authorizedWithdrawer: Account
-        clockSysvar: Address
+        clockSysvar: Account
         commission: BigInt # FIXME:*
         node: Account
-        rentSysvar: Address
+        rentSysvar: Account
         voteAccount: Account
     }
 
@@ -2572,7 +3010,7 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         newAuthority: Account
         voteAccount: Account
     }
@@ -2586,7 +3024,7 @@ var instructionTypeDefs = (
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         newAuthority: Account
         voteAccount: Account
     }
@@ -2600,7 +3038,7 @@ var instructionTypeDefs = (
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         newAuthority: Account
         voteAccount: Account
     }
@@ -2616,8 +3054,8 @@ var instructionTypeDefs = (
     """
     type VoteVoteInstruction implements TransactionInstruction {
         programId: Address
-        clockSysvar: Address
-        slotHashesSysvar: Address
+        clockSysvar: Account
+        slotHashesSysvar: Account
         vote: Vote
         voteAccount: Account
         voteAuthority: Account
@@ -2714,9 +3152,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
@@ -2729,7 +3167,7 @@ var instructionTypeDefs = (
         programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: Address
+        clockSysvar: Account
         newAuthority: Account
         voteAccount: Account
     }
@@ -2741,28 +3179,15 @@ var rootTypeDefs = (
   /* GraphQL */
   `
     type Query {
-        account(
-            address: String!
-            commitment: Commitment
-            dataSlice: DataSlice
-            encoding: AccountEncoding
-            minContextSlot: BigInt
-        ): Account
-        block(
-            slot: BigInt!
-            commitment: Commitment
-            encoding: TransactionEncoding
-            transactionDetails: BlockTransactionDetails
-        ): Block
+        account(address: Address!, commitment: Commitment, minContextSlot: Slot): Account
+        block(slot: Slot!, commitment: CommitmentWithoutProcessed): Block
         programAccounts(
-            programAddress: String!
+            programAddress: Address!
             commitment: Commitment
-            dataSlice: DataSlice
-            encoding: AccountEncoding
             filters: [ProgramAccountsFilter]
-            minContextSlot: BigInt
+            minContextSlot: Slot
         ): [Account]
-        transaction(signature: String!, commitment: Commitment, encoding: TransactionEncoding): Transaction
+        transaction(signature: Signature!, commitment: CommitmentWithoutProcessed): Transaction
     }
 
     schema {
@@ -2837,77 +3262,120 @@ var transactionTypeDefs = (
     }
 
     """
-    Transaction interface
+    A Solana transaction
     """
-    interface Transaction {
+    type Transaction {
         blockTime: BigInt
+        data(encoding: TransactionEncoding!): String
+        message: TransactionMessage
         meta: TransactionMeta
-        slot: BigInt
+        signatures: [Signature]
+        slot: Slot
         version: String
     }
+`
+);
 
-    """
-    A transaction with base58 encoded data
-    """
-    type TransactionBase58 implements Transaction {
-        blockTime: BigInt
-        data: Base58EncodedBytes
-        meta: TransactionMeta
-        slot: BigInt
-        version: String
+// src/schema/types.ts
+var typeTypeDefs = (
+  /* GraphQL */
+  `
+    enum AccountEncoding {
+        BASE_58
+        BASE_64
+        BASE_64_ZSTD
     }
 
-    """
-    A transaction with base64 encoded data
-    """
-    type TransactionBase64 implements Transaction {
-        blockTime: BigInt
+    scalar Address
+
+    scalar Base58EncodedBytes
+
+    scalar Base64EncodedBytes
+
+    scalar Base64ZstdEncodedBytes
+
+    scalar BigInt
+
+    enum Commitment {
+        CONFIRMED
+        FINALIZED
+        PROCESSED
+    }
+
+    enum CommitmentWithoutProcessed {
+        CONFIRMED
+        FINALIZED
+    }
+
+    input DataSlice {
+        offset: Int!
+        length: Int!
+    }
+
+    input ProgramAccountsFilter {
+        bytes: BigInt
+        dataSize: BigInt
+        encoding: AccountEncoding
+        offset: BigInt
+    }
+
+    type ReturnData {
         data: Base64EncodedBytes
-        meta: TransactionMeta
-        slot: BigInt
-        version: String
+        programId: Address
     }
 
-    """
-    A transaction with JSON encoded data
-    """
-    type TransactionDataParsed {
-        message: TransactionMessage
-        signatures: [String]
+    type Reward {
+        commission: Int
+        lamports: BigInt
+        postBalance: BigInt
+        pubkey: Address
+        rewardType: String
     }
-    type TransactionParsed implements Transaction {
-        blockTime: BigInt
-        data: TransactionDataParsed
-        meta: TransactionMeta
-        slot: BigInt
-        version: String
+
+    scalar Signature
+
+    scalar Slot
+
+    type TokenAmount {
+        amount: String
+        decimals: Int
+        uiAmount: BigInt
+        uiAmountString: String
+    }
+
+    type TokenBalance {
+        accountIndex: Int
+        mint: Account
+        owner: Account
+        programId: Address
+        uiTokenAmount: TokenAmount
+    }
+
+    enum TransactionEncoding {
+        BASE_58
+        BASE_64
     }
 `
 );
 
 // src/schema/index.ts
 function createSolanaGraphQLTypeDefs() {
-  return [
-    accountTypeDefs,
-    blockTypeDefs,
-    commonTypeDefs,
-    inputTypeDefs,
-    instructionTypeDefs,
-    rootTypeDefs,
-    scalarTypeDefs,
-    transactionTypeDefs
-  ];
+  return [accountTypeDefs, blockTypeDefs, instructionTypeDefs, rootTypeDefs, typeTypeDefs, transactionTypeDefs];
 }
 
 // src/index.ts
-function createRpcGraphQL(rpc) {
-  const contextValue = createSolanaGraphQLContext(rpc);
+function createRpcGraphQL(rpc, config) {
+  const rpcGraphQLConfig = {
+    maxDataSliceByteRange: config?.maxDataSliceByteRange ?? 200,
+    maxMultipleAccountsBatchSize: config?.maxMultipleAccountsBatchSize ?? 100
+  };
   const schema$1 = schema.makeExecutableSchema({
     resolvers: createSolanaGraphQLResolvers(),
     typeDefs: createSolanaGraphQLTypeDefs()
   });
   return {
     async query(source, variableValues) {
+      const contextValue = createSolanaGraphQLContext(rpc, rpcGraphQLConfig);
       return graphql.graphql({
         contextValue,
         schema: schema$1,