@solana/rpc-graphql 2.0.0-experimental.dd2096e → 2.0.0-experimental.e15a66f

package/dist/index.browser.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,40 +20,225 @@ 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 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)))
-    );
+    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 createAccountLoader(rpc) {
-  const loader = new DataLoader__default.default(createAccountBatchLoadFn(rpc), { cacheKeyFn });
+function createAccountLoader(rpc, config) {
+  const loader = new DataLoader__default.default(createAccountBatchLoadFn(rpc, config), { cacheKeyFn });
   return {
-    load: async (args) => loader.load(applyDefaultArgs(args))
+    load: async (args) => loader.load(args),
+    loadMany: async (args) => loader.loadMany(args)
   };
 }
-function applyDefaultArgs2({
+function applyDefaultArgs({
   slot,
   commitment,
   encoding = "jsonParsed",
@@ -72,61 +258,75 @@ function applyDefaultArgs2({
 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))));
-  };
+  return async (blockQueryArgs) => Promise.all(blockQueryArgs.map(async (args) => resolveBlockUsingRpc(applyDefaultArgs(args))));
 }
 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(applyDefaultArgs(args)),
+    loadMany: async (args) => loader.loadMany(args.map(applyDefaultArgs))
   };
 }
 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)))
-    );
+  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 createProgramAccountsLoader(rpc) {
-  const loader = new DataLoader__default.default(createProgramAccountsBatchLoadFn(rpc), { cacheKeyFn });
+function createProgramAccountsLoader(rpc, config) {
+  const loader = new DataLoader__default.default(createProgramAccountsBatchLoadFn(rpc, config), { cacheKeyFn });
   return {
-    load: async (args) => loader.load(applyDefaultArgs3(args))
+    load: async (args) => loader.load(args),
+    loadMany: async (args) => loader.loadMany(args)
   };
 }
-function applyDefaultArgs4({
+function applyDefaultArgs2({
   commitment,
   encoding = "jsonParsed",
   signature
@@ -140,170 +340,280 @@ function applyDefaultArgs4({
 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)))
-    );
-  };
+  return async (transactionQueryArgs) => Promise.all(transactionQueryArgs.map(async (args) => resolveTransactionUsingRpc(applyDefaultArgs2(args))));
 }
 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(applyDefaultArgs2(args)),
+    loadMany: async (args) => loader.loadMany(args.map(applyDefaultArgs2))
   };
 }
 
 // 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)
     }
   };
 }
-
-// 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;
+  }
+  checkFieldsWithVisitor(rootNode ?? null);
+  return onlyFieldsRequested2;
+}
+
+// src/resolvers/resolve-info/account.ts
+function findArgumentNodeByName(argumentNodes, name) {
+  return argumentNodes.find((argumentNode) => argumentNode.name.value === name);
+}
+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 (argumentNode.value.kind === "Variable") {
+      return variableValues[argumentNode.value.name.value];
+    }
+  } 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" });
+        }
+      }
+    });
   }
-  return false;
+  buildArgSetWithVisitor(null);
+  return argSet;
+}
+function buildAccountLoaderArgSetFromResolveInfo(args, info) {
+  return buildAccountArgSetWithVisitor(args, info);
 }
 
-// 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;
+// src/resolvers/resolve-info/program-accounts.ts
+function buildProgramAccountsLoaderArgSetFromResolveInfo(args, info) {
+  return buildAccountArgSetWithVisitor(args, info);
 }
-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/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) {
-      return null;
-    }
-    if (onlyPresentFieldRequested("address", info)) {
-      return { address };
-    }
-    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";
-      }
-      if (account.encoding === "base64") {
-        return "AccountBase64";
+    if (address) {
+      if (onlyFieldsRequested(["address"], info)) {
+        return { address };
       }
-      if (account.encoding === "base64+zstd") {
-        return "AccountBase64Zstd";
-      }
-      if (account.encoding === "jsonParsed") {
-        if (account.programName === "nonce") {
-          return "NonceAccount";
-        }
-        if (account.accountType === "mint" && account.programName === "spl-token") {
-          return "MintAccount";
+      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.accountType === "account" && account.programName === "spl-token") {
-          return "TokenAccount";
+        if (account === null) {
+          return;
         }
-        if (account.programName === "stake") {
-          return "StakeAccount";
+        if (!result.ownerProgram) {
+          result = {
+            ...result,
+            ...account,
+            ownerProgram: account.owner
+          };
         }
-        if (account.accountType === "vote" && account.programName === "vote") {
-          return "VoteAccount";
-        }
-        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: {
@@ -317,12 +627,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")
   },
@@ -382,7 +694,7 @@ function resolveTransaction(fieldName) {
     if (!signature) {
       return null;
     }
-    if (onlyPresentFieldRequested("signature", info)) {
+    if (onlyFieldsRequested(["signature"], info)) {
       return { signature };
     }
     const transaction = await context.loaders.transaction.load({ ...args, signature });
@@ -448,7 +760,7 @@ var resolveBlock = (fieldName) => {
     if (!slot) {
       return null;
     }
-    if (onlyPresentFieldRequested("slot", info)) {
+    if (onlyFieldsRequested(["slot"], info)) {
       return { slot };
     }
     const block = await context.loaders.block.load({ ...args, slot });
@@ -1197,20 +1509,57 @@ var instructionResolvers = {
 function resolveProgramAccounts(fieldName) {
   return async (parent, args, context, info) => {
     const programAddress = fieldName ? parent[fieldName] : args.programAddress;
-    if (!programAddress) {
-      return null;
+    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);
     }
-    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
-      })
-    );
+    return null;
   };
 }
 
@@ -1237,35 +1586,44 @@ 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) {
+      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,
+  BlockTransactionDetails: {
+    ACCOUNTS: "accounts",
+    FULL: "full",
+    NONE: "none",
+    SIGNATURES: "signatures"
+  },
+  Commitment: {
+    CONFIRMED: "confirmed",
+    FINALIZED: "finalized",
+    PROCESSED: "processed"
+  },
+  Signature: stringScalarAlias,
+  Slot: bigIntScalarAlias,
   TokenBalance: {
     mint: resolveAccount("mint"),
     owner: resolveAccount("owner")
@@ -1286,11 +1644,10 @@ function createSolanaGraphQLResolvers() {
   return {
     ...accountResolvers,
     ...blockResolvers,
-    ...commonTypeResolvers,
     ...instructionResolvers,
     ...rootResolvers,
-    ...scalarResolvers,
-    ...transactionResolvers
+    ...transactionResolvers,
+    ...typeTypeResolvers
   };
 }
 
@@ -1303,6 +1660,7 @@ var accountTypeDefs = (
     """
     interface Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1311,37 +1669,11 @@ var accountTypeDefs = (
     }
 
     """
-    An account with base58 encoded data
-    """
-    type AccountBase58 implements Account {
-        address: Address
-        data: Base58EncodedBytes
-        executable: Boolean
-        lamports: BigInt
-        ownerProgram: Account
-        space: BigInt
-        rentEpoch: BigInt
-    }
-
-    """
-    An account with base64 encoded data
+    Generic base account type
     """
-    type AccountBase64 implements Account {
+    type GenericAccount 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
@@ -1357,6 +1689,7 @@ var accountTypeDefs = (
     """
     type NonceAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1372,6 +1705,7 @@ var accountTypeDefs = (
     """
     type LookupTableAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1389,6 +1723,7 @@ var accountTypeDefs = (
     """
     type MintAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1406,6 +1741,7 @@ var accountTypeDefs = (
     """
     type TokenAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1448,6 +1784,7 @@ var accountTypeDefs = (
     """
     type StakeAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1479,6 +1816,7 @@ var accountTypeDefs = (
     """
     type VoteAccount implements Account {
         address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
         executable: Boolean
         lamports: BigInt
         ownerProgram: Account
@@ -1592,101 +1930,6 @@ var blockTypeDefs = (
 `
 );
 
-// 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
-    }
-`
-);
-
 // src/schema/instruction.ts
 var instructionTypeDefs = (
   /* GraphQL */
@@ -2740,28 +2983,20 @@ var rootTypeDefs = (
   /* GraphQL */
   `
     type Query {
-        account(
-            address: String!
-            commitment: Commitment
-            dataSlice: DataSlice
-            encoding: AccountEncoding
-            minContextSlot: BigInt
-        ): Account
+        account(address: Address!, commitment: Commitment, minContextSlot: Slot): Account
         block(
-            slot: BigInt!
+            slot: Slot!
             commitment: Commitment
             encoding: TransactionEncoding
             transactionDetails: BlockTransactionDetails
         ): 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: Commitment, encoding: TransactionEncoding): Transaction
     }
 
     schema {
@@ -2884,29 +3119,114 @@ var transactionTypeDefs = (
 `
 );
 
+// src/schema/types.ts
+var typeTypeDefs = (
+  /* GraphQL */
+  `
+    enum AccountEncoding {
+        BASE_58
+        BASE_64
+        BASE_64_ZSTD
+    }
+
+    scalar Address
+
+    scalar Base58EncodedBytes
+
+    scalar Base64EncodedBytes
+
+    scalar Base64ZstdEncodedBytes
+
+    scalar BigInt
+
+    enum BlockTransactionDetails {
+        ACCOUNTS
+        FULL
+        NONE
+        SIGNATURES
+    }
+
+    enum Commitment {
+        CONFIRMED
+        FINALIZED
+        PROCESSED
+    }
+
+    input DataSlice {
+        offset: Int!
+        length: Int!
+    }
+
+    input ProgramAccountsFilter {
+        bytes: BigInt
+        dataSize: BigInt
+        encoding: AccountEncoding
+        offset: BigInt
+    }
+
+    type ReturnData {
+        data: Base64EncodedBytes
+        programId: Address
+    }
+
+    type Reward {
+        commission: Int
+        lamports: BigInt
+        postBalance: BigInt
+        pubkey: Address
+        rewardType: 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
+        PARSED
+    }
+
+    enum TransactionVersion {
+        LEGACY
+        ZERO
+    }
+`
+);
+
 // 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) {
+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);
+      const contextValue = createSolanaGraphQLContext(rpc, rpcGraphQLConfig);
       return graphql.graphql({
         contextValue,
         schema: schema$1,