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

package/dist/index.node.cjs

@@ -1,71 +1,3388 @@
 'use strict';
 
+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');
 
-// src/rpc.ts
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-// src/cache.ts
-var inMemoryCache = {};
-var stringifyValue = (value) => JSON.stringify(value, (_, value2) => {
-  if (typeof value2 === "bigint") {
-    return value2.toString() + "n";
+var DataLoader__default = /*#__PURE__*/_interopDefault(DataLoader);
+var stringify__default = /*#__PURE__*/_interopDefault(stringify);
+
+// src/index.ts
+function replacer(_, value) {
+  if (typeof value === "bigint") {
+    return value.toString() + "n";
   }
-  return value2;
-});
-var parseValue = (value) => JSON.parse(value, (_, value2) => {
-  if (typeof value2 === "string" && /\d+n$/.test(value2)) {
-    return BigInt(value2.slice(0, -1));
+  return 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 getCodec(encoding) {
+  switch (encoding) {
+    case "base58":
+      return codecsStrings.getBase58Codec();
+    default:
+      return codecsStrings.getBase64Codec();
   }
-  return value2;
-});
-var cacheKey = (key, variables) => `GraphQLCache:${stringifyValue(key)}:${stringifyValue(variables)}`;
-function createGraphQLCache() {
+}
+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);
+}
+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) => {
+    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, config) {
+  const loader = new DataLoader__default.default(createAccountBatchLoadFn(rpc, config), { cacheKeyFn });
   return {
-    // Node.js
-    flush: () => {
-      Object.keys(inMemoryCache).forEach((key) => delete inMemoryCache[key]);
-    },
-    get: (key, variables) => {
-      const value = inMemoryCache[cacheKey(key, variables)];
-      return value === void 0 ? null : parseValue(value);
-    },
-    insert: (key, variables, value) => {
-      inMemoryCache[cacheKey(key, variables)] = stringifyValue(value);
+    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/microsoft/TypeScript/issues/43187
+    config
+  ).send();
+}
+function createBlockBatchLoadFn(rpc) {
+  const resolveBlockUsingRpc = loadBlock.bind(null, rpc);
+  return async (blockQueryArgs) => {
+    const blocksToFetch = {};
+    try {
+      return Promise.all(
+        blockQueryArgs.map(
+          ({ slot, ...args }) => new Promise((resolve, reject) => {
+            const blockRecords = blocksToFetch[slot.toString()] ||= [];
+            if (!args.commitment) {
+              args.commitment = "confirmed";
+            }
+            blockRecords.push({ args, promiseCallback: { reject, resolve } });
+          })
+        )
+      );
+    } finally {
+      const blockFetchesByArgsHash = buildCoalescedFetchesByArgsHash(blocksToFetch, {
+        criteria: (args) => args.encoding === void 0 && args.transactionDetails !== "signatures",
+        defaults: (args) => ({
+          ...args,
+          transactionDetails: "none"
+        }),
+        hashOmit: ["encoding", "transactionDetails"]
+      });
+      Object.values(blockFetchesByArgsHash).map(({ args, fetches: blockCallbacks }) => {
+        return Object.entries(blockCallbacks).map(([slot, { callbacks }]) => {
+          return Array.from({ length: 1 }, async () => {
+            try {
+              const result = await resolveBlockUsingRpc({
+                slot: BigInt(slot),
+                ...args
+              });
+              callbacks.forEach((c) => c.resolve(result));
+            } catch (e) {
+              callbacks.forEach((c) => c.reject(e));
+            }
+          });
+        });
+      });
+    }
+  };
+}
+function createBlockLoader(rpc) {
+  const loader = new DataLoader__default.default(createBlockBatchLoadFn(rpc), { cacheKeyFn });
+  return {
+    load: async (args) => loader.load({ ...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/microsoft/TypeScript/issues/43187
+    config
+  ).send();
+}
+function createProgramAccountsBatchLoadFn(rpc, config) {
+  const resolveProgramAccountsUsingRpc = loadProgramAccounts.bind(null, rpc);
+  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, config) {
+  const loader = new DataLoader__default.default(createProgramAccountsBatchLoadFn(rpc, config), { cacheKeyFn });
+  return {
+    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/microsoft/TypeScript/issues/43187
+    config
+  ).send();
+}
+function createTransactionBatchLoadFn(rpc) {
+  const resolveTransactionUsingRpc = loadTransaction.bind(null, rpc);
+  return async (transactionQueryArgs) => {
+    const transactionsToFetch = {};
+    try {
+      return Promise.all(
+        transactionQueryArgs.map(
+          ({ signature, ...args }) => new Promise((resolve, reject) => {
+            const transactionRecords = transactionsToFetch[signature] ||= [];
+            if (!args.commitment) {
+              args.commitment = "confirmed";
+            }
+            transactionRecords.push({ args, promiseCallback: { reject, resolve } });
+          })
+        )
+      );
+    } 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(args),
+    loadMany: async (args) => loader.loadMany(args)
+  };
+}
 
 // src/context.ts
-function createSolanaGraphQLContext(rpc) {
-  const cache = createGraphQLCache();
-  return { cache, rpc };
-}
-
-// src/rpc.ts
-function createRpcGraphQL(rpc) {
-  const context = createSolanaGraphQLContext(rpc);
-  const schema = new graphql.GraphQLSchema({
-    query: new graphql.GraphQLObjectType({
-      fields: {
-        /** Root queries */
+function createSolanaGraphQLContext(rpc, config) {
+  return {
+    loaders: {
+      account: createAccountLoader(rpc, config),
+      block: createBlockLoader(rpc),
+      programAccounts: createProgramAccountsLoader(rpc, config),
+      transaction: createTransactionLoader(rpc)
+    }
+  };
+}
+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);
+      }
+    });
+  }
+  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" });
+        }
+      }
+    });
+  }
+  buildArgSetWithVisitor(null);
+  return argSet;
+}
+function buildAccountLoaderArgSetFromResolveInfo(args, info) {
+  return buildAccountArgSetWithVisitor(args, info);
+}
+
+// src/resolvers/resolve-info/transaction.ts
+function findArgumentNodeByName2(argumentNodes, name) {
+  return argumentNodes.find((argumentNode) => argumentNode.name.value === name);
+}
+function parseTransactionEncodingArgument(argumentNodes, variableValues) {
+  const argumentNode = findArgumentNodeByName2(argumentNodes, "encoding");
+  if (argumentNode) {
+    if (argumentNode.value.kind === "EnumValue") {
+      if (argumentNode.value.value === "BASE_58") {
+        return "base58";
+      }
+      if (argumentNode.value.value === "BASE_64") {
+        return "base64";
+      }
+    }
+    if (argumentNode.value.kind === "Variable") {
+      return variableValues[argumentNode.value.name.value];
+    }
+  } else {
+    return void 0;
+  }
+}
+function buildTransactionArgSetWithVisitor(args, info) {
+  const argSet = [args];
+  function buildArgSetWithVisitor(root) {
+    injectableRootVisitor(info, root, {
+      fieldNodeOperation(info2, node) {
+        if (node.name.value === "message" || node.name.value === "meta") {
+          argSet.push({ ...args, encoding: "jsonParsed" });
+        } else if (node.name.value === "data") {
+          if (node.arguments) {
+            const { variableValues } = info2;
+            const encoding = parseTransactionEncodingArgument(
+              node.arguments,
+              variableValues
+            );
+            argSet.push({ ...args, encoding });
+          }
+        }
       },
-      name: "RootQuery"
-    }),
-    types: []
+      fragmentSpreadNodeOperation(_info, fragment) {
+        buildArgSetWithVisitor(fragment);
+      },
+      inlineFragmentNodeOperation(_info, _node) {
+        return;
+      }
+    });
+  }
+  buildArgSetWithVisitor(null);
+  return argSet;
+}
+function buildTransactionLoaderArgSetFromResolveInfo(args, info) {
+  return buildTransactionArgSetWithVisitor(args, info);
+}
+
+// src/resolvers/resolve-info/block.ts
+function buildBlockLoaderArgSetFromResolveInfo(args, info) {
+  const argSet = [args];
+  function buildArgSetWithVisitor(root) {
+    injectableRootVisitor(info, root, {
+      fieldNodeOperation(info2, node) {
+        if (node.name.value === "signatures") {
+          argSet.push({ ...args, transactionDetails: "signatures" });
+        } else if (node.name.value === "transactions") {
+          argSet.push(...buildTransactionArgSetWithVisitor({ ...args, transactionDetails: "full" }, info2));
+        }
+      },
+      fragmentSpreadNodeOperation(_info, fragment) {
+        buildArgSetWithVisitor(fragment);
+      },
+      inlineFragmentNodeOperation(_info, _node) {
+        return;
+      }
+    });
+  }
+  buildArgSetWithVisitor(null);
+  return argSet;
+}
+
+// src/resolvers/resolve-info/program-accounts.ts
+function buildProgramAccountsLoaderArgSetFromResolveInfo(args, info) {
+  return buildAccountArgSetWithVisitor(args, info);
+}
+
+// src/resolvers/account.ts
+var resolveAccountData = () => {
+  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 === null) {
+          return;
+        }
+        if (!result.ownerProgram) {
+          result = {
+            ...result,
+            ...account,
+            ownerProgram: account.owner
+          };
+        }
+        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 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()
+  },
+  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: {
+    staker: resolveAccount("staker"),
+    withdrawer: resolveAccount("withdrawer")
+  },
+  StakeAccountDataMetaLockup: {
+    custodian: resolveAccount("custodian")
+  },
+  StakeAccountDataStakeDelegation: {
+    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")
+  },
+  VoteAccountDataAuthorizedVoter: {
+    authorizedVoter: resolveAccount("authorizedVoter")
+  }
+};
+
+// src/resolvers/transaction.ts
+function mapJsonParsedInstructions(instructions) {
+  return instructions.map((instruction) => {
+    if ("parsed" in instruction) {
+      if (typeof instruction.parsed === "string" && instruction.program === "spl-memo") {
+        const { parsed: memo, program: programName2, programId: programId2 } = instruction;
+        const instructionType2 = "memo";
+        const jsonParsedConfigs2 = {
+          instructionType: instructionType2,
+          programId: programId2,
+          programName: programName2
+        };
+        return { jsonParsedConfigs: jsonParsedConfigs2, memo, programId: programId2 };
+      }
+      const {
+        parsed: { info: data, type: instructionType },
+        program: programName,
+        programId
+      } = instruction;
+      const jsonParsedConfigs = {
+        instructionType,
+        programId,
+        programName
+      };
+      return { jsonParsedConfigs, ...data, programId };
+    } else {
+      return instruction;
+    }
+  });
+}
+function mapJsonParsedInnerInstructions(innerInstructions) {
+  return innerInstructions.map(({ index, instructions }) => ({
+    index,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    instructions: mapJsonParsedInstructions(instructions)
+  }));
+}
+var resolveTransactionData = () => {
+  return (parent, args) => {
+    return parent === null ? null : parent.encodedData ? parent.encodedData[cacheKeyFn(args)] : null;
+  };
+};
+function resolveTransaction(fieldName) {
+  return async (parent, args, context, info) => {
+    const signature = fieldName ? parent[fieldName] : args.signature;
+    if (signature) {
+      if (onlyFieldsRequested(["signature"], info)) {
+        return { signature };
+      }
+      const argsSet = buildTransactionLoaderArgSetFromResolveInfo({ ...args, signature }, info);
+      const loadedTransactions = await context.loaders.transaction.loadMany(argsSet);
+      let result = {
+        encodedData: {},
+        signature
+      };
+      loadedTransactions.forEach((loadedTransaction, i) => {
+        if (loadedTransaction instanceof Error) {
+          console.error(loadedTransaction);
+          return;
+        }
+        if (loadedTransaction === null) {
+          return;
+        }
+        if (!result.slot) {
+          result = {
+            ...result,
+            ...loadedTransaction
+          };
+        }
+        const { transaction: data } = loadedTransaction;
+        const { encoding } = argsSet[i];
+        if (encoding && result.encodedData) {
+          if (Array.isArray(data)) {
+            result.encodedData[cacheKeyFn({
+              encoding
+            })] = data[0];
+          } else if (typeof data === "object") {
+            const jsonParsedData = data;
+            jsonParsedData.message.instructions = mapJsonParsedInstructions(
+              jsonParsedData.message.instructions
+            );
+            const loadedInnerInstructions = loadedTransaction.meta?.innerInstructions;
+            if (loadedInnerInstructions) {
+              const innerInstructions = mapJsonParsedInnerInstructions(loadedInnerInstructions);
+              const jsonParsedMeta = {
+                ...loadedTransaction.meta,
+                innerInstructions
+              };
+              result = {
+                ...result,
+                ...jsonParsedData,
+                meta: jsonParsedMeta
+              };
+            } else {
+              result = {
+                ...result,
+                ...jsonParsedData
+              };
+            }
+          }
+        }
+      });
+      return result;
+    }
+    return null;
+  };
+}
+var transactionResolvers = {
+  Transaction: {
+    data: resolveTransactionData()
+  }
+};
+
+// src/resolvers/block.ts
+var resolveBlock = (fieldName) => {
+  return async (parent, args, context, info) => {
+    const slot = fieldName ? parent[fieldName] : args.slot;
+    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;
+    }
+    return null;
+  };
+};
+var blockResolvers = {
+  Block: {
+    transactions: (parent) => parent?.transactionResults ? Object.values(parent.transactionResults) : null
+  }
+};
+
+// src/resolvers/instruction.ts
+var instructionResolvers = {
+  AdvanceNonceAccountInstruction: {
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority"),
+    recentBlockhashesSysvar: resolveAccount("recentBlockhashesSysvar")
+  },
+  AllocateInstruction: {
+    account: resolveAccount("account")
+  },
+  AllocateWithSeedInstruction: {
+    account: resolveAccount("account"),
+    owner: resolveAccount("owner")
+  },
+  AssignInstruction: {
+    account: resolveAccount("account"),
+    owner: resolveAccount("owner")
+  },
+  AssignWithSeedInstruction: {
+    account: resolveAccount("account"),
+    owner: resolveAccount("owner")
+  },
+  AuthorizeNonceAccountInstruction: {
+    newAuthorized: resolveAccount("newAuthorized"),
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  },
+  BpfLoaderFinalizeInstruction: {
+    account: resolveAccount("account")
+  },
+  BpfLoaderWriteInstruction: {
+    account: resolveAccount("account")
+  },
+  BpfUpgradeableLoaderCloseInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    programAccount: resolveAccount("programAccount"),
+    recipient: resolveAccount("recipient")
+  },
+  BpfUpgradeableLoaderDeployWithMaxDataLenInstruction: {
+    authority: resolveAccount("authority"),
+    bufferAccount: resolveAccount("bufferAccount"),
+    clockSysvar: resolveAccount("clockSysvar"),
+    payerAccount: resolveAccount("payerAccount"),
+    programAccount: resolveAccount("programAccount"),
+    programDataAccount: resolveAccount("programDataAccount"),
+    rentSysvar: resolveAccount("rentSysvar")
+  },
+  BpfUpgradeableLoaderExtendProgramInstruction: {
+    payerAccount: resolveAccount("payerAccount"),
+    programAccount: resolveAccount("programAccount"),
+    programDataAccount: resolveAccount("programDataAccount"),
+    systemProgram: resolveAccount("systemProgram")
+  },
+  BpfUpgradeableLoaderInitializeBufferInstruction: {
+    account: resolveAccount("account")
+  },
+  BpfUpgradeableLoaderSetAuthorityCheckedInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  BpfUpgradeableLoaderSetAuthorityInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  BpfUpgradeableLoaderUpgradeInstruction: {
+    authority: resolveAccount("authority"),
+    bufferAccount: resolveAccount("bufferAccount"),
+    clockSysvar: resolveAccount("clockSysvar"),
+    programAccount: resolveAccount("programAccount"),
+    programDataAccount: resolveAccount("programDataAccount"),
+    rentSysvar: resolveAccount("rentSysvar")
+  },
+  BpfUpgradeableLoaderWriteInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority")
+  },
+  CloseLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority"),
+    recipient: resolveAccount("recipient")
+  },
+  CreateAccountInstruction: {
+    newAccount: resolveAccount("newAccount"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
+  },
+  CreateAccountWithSeedInstruction: {
+    base: resolveAccount("base"),
+    owner: resolveAccount("owner"),
+    seed: resolveAccount("seed")
+  },
+  CreateLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority"),
+    payerAccount: resolveAccount("payerAccount"),
+    systemProgram: resolveAccount("systemProgram")
+  },
+  DeactivateLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority")
+  },
+  ExtendLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority"),
+    payerAccount: resolveAccount("payerAccount"),
+    systemProgram: resolveAccount("systemProgram")
+  },
+  FreezeLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority")
+  },
+  InitializeNonceAccountInstruction: {
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority"),
+    recentBlockhashesSysvar: resolveAccount("recentBlockhashesSysvar"),
+    rentSysvar: resolveAccount("rentSysvar")
+  },
+  Lockup: {
+    custodian: resolveAccount("custodian")
+  },
+  SplAssociatedTokenCreateIdempotentInstruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    source: resolveAccount("source"),
+    systemProgram: resolveAccount("systemProgram"),
+    tokenProgram: resolveAccount("tokenProgram"),
+    wallet: resolveAccount("wallet")
+  },
+  SplAssociatedTokenCreateInstruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    source: resolveAccount("source"),
+    systemProgram: resolveAccount("systemProgram"),
+    tokenProgram: resolveAccount("tokenProgram"),
+    wallet: resolveAccount("wallet")
+  },
+  SplAssociatedTokenRecoverNestedInstruction: {
+    destination: resolveAccount("destination"),
+    nestedMint: resolveAccount("nestedMint"),
+    nestedOwner: resolveAccount("nestedOwner"),
+    nestedSource: resolveAccount("nestedSource"),
+    ownerMint: resolveAccount("ownerMint"),
+    tokenProgram: resolveAccount("tokenProgram"),
+    wallet: resolveAccount("wallet")
+  },
+  SplTokenAmountToUiAmountInstruction: {
+    mint: resolveAccount("mint")
+  },
+  SplTokenApproveCheckedInstruction: {
+    delegate: resolveAccount("delegate"),
+    mint: resolveAccount("mint"),
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
+  },
+  SplTokenApproveInstruction: {
+    delegate: resolveAccount("delegate"),
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
+  },
+  SplTokenBurnCheckedInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    multisigAuthority: resolveAccount("multisigAuthority")
+  },
+  SplTokenBurnInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    multisigAuthority: resolveAccount("multisigAuthority")
+  },
+  SplTokenCloseAccountInstruction: {
+    account: resolveAccount("account"),
+    destination: resolveAccount("destination"),
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner")
+  },
+  SplTokenFreezeAccountInstruction: {
+    account: resolveAccount("account"),
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    multisigFreezeAuthority: resolveAccount("multisigFreezeAuthority")
+  },
+  SplTokenGetAccountDataSizeInstruction: {
+    mint: resolveAccount("mint")
+  },
+  SplTokenInitializeAccount2Instruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner"),
+    rentSysvar: resolveAccount("rentSysvar")
+  },
+  SplTokenInitializeAccount3Instruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner")
+  },
+  SplTokenInitializeAccountInstruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner"),
+    rentSysvar: resolveAccount("rentSysvar")
+  },
+  SplTokenInitializeMint2Instruction: {
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority")
+  },
+  SplTokenInitializeMintCloseAuthorityInstruction: {
+    mint: resolveAccount("mint"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  SplTokenInitializeMintInstruction: {
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    rentSysvar: resolveAccount("rentSysvar")
+  },
+  SplTokenInitializeMultisig2Instruction: {
+    multisig: resolveAccount("multisig")
+  },
+  SplTokenInitializeMultisigInstruction: {
+    multisig: resolveAccount("multisig"),
+    rentSysvar: resolveAccount("rentSysvar")
+  },
+  SplTokenMintToCheckedInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    multisigMintAuthority: resolveAccount("multisigMintAuthority")
+  },
+  SplTokenMintToInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    multisigMintAuthority: resolveAccount("multisigMintAuthority")
+  },
+  SplTokenRevokeInstruction: {
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
+  },
+  SplTokenSetAuthorityInstruction: {
+    authority: resolveAccount("authority"),
+    multisigAuthority: resolveAccount("multisigAuthority"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  SplTokenSyncNativeInstruction: {
+    account: resolveAccount("account")
+  },
+  SplTokenThawAccountInstruction: {
+    account: resolveAccount("account"),
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    multisigFreezeAuthority: resolveAccount("multisigFreezeAuthority")
+  },
+  SplTokenTransferCheckedInstruction: {
+    authority: resolveAccount("authority"),
+    destination: resolveAccount("destination"),
+    mint: resolveAccount("mint"),
+    multisigAuthority: resolveAccount("multisigAuthority"),
+    source: resolveAccount("source")
+  },
+  SplTokenTransferInstruction: {
+    authority: resolveAccount("authority"),
+    destination: resolveAccount("destination"),
+    multisigAuthority: resolveAccount("multisigAuthority"),
+    source: resolveAccount("source")
+  },
+  SplTokenUiAmountToAmountInstruction: {
+    mint: resolveAccount("mint")
+  },
+  StakeAuthorizeCheckedInstruction: {
+    authority: resolveAccount("authority"),
+    clockSysvar: resolveAccount("clockSysvar"),
+    custodian: resolveAccount("custodian"),
+    newAuthority: resolveAccount("newAuthority"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  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")
+  },
+  StakeAuthorizeWithSeedInstruction: {
+    authorityBase: resolveAccount("authorityBase"),
+    authorityOwner: resolveAccount("authorityOwner"),
+    clockSysvar: resolveAccount("clockSysvar"),
+    custodian: resolveAccount("custodian"),
+    newAuthorized: resolveAccount("newAuthorized"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeDeactivateDelinquentInstruction: {
+    referenceVoteAccount: resolveAccount("referenceVoteAccount"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    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: {
+    staker: resolveAccount("staker"),
+    withdrawer: resolveAccount("withdrawer")
+  },
+  StakeMergeInstruction: {
+    clockSysvar: resolveAccount("clockSysvar"),
+    destination: resolveAccount("destination"),
+    source: resolveAccount("source"),
+    stakeAuthority: resolveAccount("stakeAuthority"),
+    stakeHistorySysvar: resolveAccount("stakeHistorySysvar")
+  },
+  StakeRedelegateInstruction: {
+    newStakeAccount: resolveAccount("newStakeAccount"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority"),
+    stakeConfigAccount: resolveAccount("stakeConfigAccount"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  StakeSetLockupCheckedInstruction: {
+    custodian: resolveAccount("custodian"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeSetLockupInstruction: {
+    custodian: resolveAccount("custodian"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeSplitInstruction: {
+    newSplitAccount: resolveAccount("newSplitAccount"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority")
+  },
+  StakeWithdrawInstruction: {
+    clockSysvar: resolveAccount("clockSysvar"),
+    destination: resolveAccount("destination"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
+  },
+  TransactionInstruction: {
+    __resolveType(instructionResult) {
+      const { jsonParsedConfigs } = instructionResult;
+      if (jsonParsedConfigs) {
+        if (jsonParsedConfigs.programName === "address-lookup-table") {
+          if (jsonParsedConfigs.instructionType === "createLookupTable") {
+            return "CreateLookupTableInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "freezeLookupTable") {
+            return "FreezeLookupTableInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "extendLookupTable") {
+            return "ExtendLookupTableInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "deactivateLookupTable") {
+            return "DeactivateLookupTableInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "closeLookupTable") {
+            return "CloseLookupTableInstruction";
+          }
+        }
+        if (jsonParsedConfigs.programName === "bpf-loader") {
+          if (jsonParsedConfigs.instructionType === "write") {
+            return "BpfLoaderWriteInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "finalize") {
+            return "BpfLoaderFinalizeInstruction";
+          }
+        }
+        if (jsonParsedConfigs.programName === "bpf-upgradeable-loader") {
+          if (jsonParsedConfigs.instructionType === "initializeBuffer") {
+            return "BpfUpgradeableLoaderInitializeBufferInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "write") {
+            return "BpfUpgradeableLoaderWriteInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "deployWithMaxDataLen") {
+            return "BpfUpgradeableLoaderDeployWithMaxDataLenInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "upgrade") {
+            return "BpfUpgradeableLoaderUpgradeInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "setAuthority") {
+            return "BpfUpgradeableLoaderSetAuthorityInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "setAuthorityChecked") {
+            return "BpfUpgradeableLoaderSetAuthorityCheckedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "close") {
+            return "BpfUpgradeableLoaderCloseInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "extendProgram") {
+            return "BpfUpgradeableLoaderExtendProgramInstruction";
+          }
+        }
+        if (jsonParsedConfigs.programName === "spl-associated-token-account") {
+          if (jsonParsedConfigs.instructionType === "create") {
+            return "SplAssociatedTokenCreateInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "createIdempotent") {
+            return "SplAssociatedTokenCreateIdempotentInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "recoverNested") {
+            return "SplAssociatedTokenRecoverNestedInstruction";
+          }
+        }
+        if (jsonParsedConfigs.programName === "spl-memo") {
+          return "SplMemoInstruction";
+        }
+        if (jsonParsedConfigs.programName === "spl-token") {
+          if (jsonParsedConfigs.instructionType === "initializeMint") {
+            return "SplTokenInitializeMintInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeMint2") {
+            return "SplTokenInitializeMint2Instruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeAccount") {
+            return "SplTokenInitializeAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeAccount2") {
+            return "SplTokenInitializeAccount2Instruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeAccount3") {
+            return "SplTokenInitializeAccount3Instruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeMultisig") {
+            return "SplTokenInitializeMultisigInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeMultisig2") {
+            return "SplTokenInitializeMultisig2Instruction";
+          }
+          if (jsonParsedConfigs.instructionType === "transfer") {
+            return "SplTokenTransferInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "approve") {
+            return "SplTokenApproveInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "revoke") {
+            return "SplTokenRevokeInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "setAuthority") {
+            return "SplTokenSetAuthorityInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "mintTo") {
+            return "SplTokenMintToInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "burn") {
+            return "SplTokenBurnInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "closeAccount") {
+            return "SplTokenCloseAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "freezeAccount") {
+            return "SplTokenFreezeAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "thawAccount") {
+            return "SplTokenThawAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "transferChecked") {
+            return "SplTokenTransferCheckedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "approveChecked") {
+            return "SplTokenApproveCheckedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "mintToChecked") {
+            return "SplTokenMintToCheckedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "burnChecked") {
+            return "SplTokenBurnCheckedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "syncNative") {
+            return "SplTokenSyncNativeInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "getAccountDataSize") {
+            return "SplTokenGetAccountDataSizeInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeImmutableOwner") {
+            return "SplTokenInitializeImmutableOwnerInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "amountToUiAmount") {
+            return "SplTokenAmountToUiAmountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "uiAmountToAmount") {
+            return "SplTokenUiAmountToAmountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeMintCloseAuthority") {
+            return "SplTokenInitializeMintCloseAuthorityInstruction";
+          }
+        }
+        if (jsonParsedConfigs.programName === "stake") {
+          if (jsonParsedConfigs.instructionType === "initialize") {
+            return "StakeInitializeInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "authorize") {
+            return "StakeAuthorizeInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "delegate") {
+            return "StakeDelegateStakeInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "split") {
+            return "StakeSplitInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "withdraw") {
+            return "StakeWithdrawInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "deactivate") {
+            return "StakeDeactivateInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "setLockup") {
+            return "StakeSetLockupInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "merge") {
+            return "StakeMergeInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "authorizeWithSeed") {
+            return "StakeAuthorizeWithSeedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeChecked") {
+            return "StakeInitializeCheckedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "authorizeChecked") {
+            return "StakeAuthorizeCheckedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "authorizeCheckedWithSeed") {
+            return "StakeAuthorizeCheckedWithSeedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "setLockupChecked") {
+            return "StakeSetLockupCheckedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "deactivateDelinquent") {
+            return "StakeDeactivateDelinquentInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "redelegate") {
+            return "StakeRedelegateInstruction";
+          }
+        }
+        if (jsonParsedConfigs.programName === "system") {
+          if (jsonParsedConfigs.instructionType === "createAccount") {
+            return "CreateAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "assign") {
+            return "AssignInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "transfer") {
+            return "TransferInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "createAccountWithSeed") {
+            return "CreateAccountWithSeedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "advanceNonceAccount") {
+            return "AdvanceNonceAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "withdrawNonceAccount") {
+            return "WithdrawNonceAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "initializeNonceAccount") {
+            return "InitializeNonceAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "authorizeNonceAccount") {
+            return "AuthorizeNonceAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "upgradeNonceAccount") {
+            return "UpgradeNonceAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "allocate") {
+            return "AllocateInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "allocateWithSeed") {
+            return "AllocateWithSeedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "assignWithSeed") {
+            return "AssignWithSeedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "transferWithSeed") {
+            return "TransferWithSeedInstruction";
+          }
+        }
+        if (jsonParsedConfigs.programName === "vote") {
+          if (jsonParsedConfigs.instructionType === "initialize") {
+            return "VoteInitializeAccountInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "authorize") {
+            return "VoteAuthorizeInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "authorizeWithSeed") {
+            return "VoteAuthorizeWithSeedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "authorizeCheckedWithSeed") {
+            return "VoteAuthorizeCheckedWithSeedInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "vote") {
+            return "VoteVoteInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "updatevotestate") {
+            return "VoteUpdateVoteStateInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "updatevotestateswitch") {
+            return "VoteUpdateVoteStateSwitchInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "compactupdatevotestate") {
+            return "VoteCompactUpdateVoteStateInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "compactupdatevotestateswitch") {
+            return "VoteCompactUpdateVoteStateSwitchInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "withdraw") {
+            return "VoteWithdrawInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "updateValidatorIdentity") {
+            return "VoteUpdateValidatorIdentityInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "updateCommission") {
+            return "VoteUpdateCommissionInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "voteSwitch") {
+            return "VoteVoteSwitchInstruction";
+          }
+          if (jsonParsedConfigs.instructionType === "authorizeChecked") {
+            return "VoteAuthorizeCheckedInstruction";
+          }
+        }
+      }
+      return "GenericInstruction";
+    }
+  },
+  TransferInstruction: {
+    destination: resolveAccount("destination"),
+    source: resolveAccount("source")
+  },
+  TransferWithSeedInstruction: {
+    destination: resolveAccount("destination"),
+    source: resolveAccount("source"),
+    sourceOwner: resolveAccount("sourceOwner")
+  },
+  UpgradeNonceAccountInstruction: {
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  },
+  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")
+  },
+  VoteCompactUpdateVoteStateInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
+  },
+  VoteCompactUpdateVoteStateSwitchInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
+  },
+  VoteInitializeAccountInstruction: {
+    authorizedVoter: resolveAccount("authorizedVoter"),
+    authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
+    clockSysvar: resolveAccount("clockSysvar"),
+    node: resolveAccount("node"),
+    rentSysvar: resolveAccount("rentSysvar"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  VoteUpdateCommissionInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
+  },
+  VoteUpdateValidatorIdentityInstruction: {
+    newValidatorIdentity: resolveAccount("newValidatorIdentity"),
+    voteAccount: resolveAccount("voteAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
+  },
+  VoteUpdateVoteStateInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
+  },
+  VoteUpdateVoteStateSwitchInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    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")
+  },
+  VoteWithdrawInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
+  },
+  WithdrawNonceAccountInstruction: {
+    destination: resolveAccount("destination"),
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority"),
+    recentBlockhashesSysvar: resolveAccount("recentBlockhashesSysvar"),
+    rentSysvar: resolveAccount("rentSysvar")
+  }
+};
+
+// src/resolvers/program-accounts.ts
+function resolveProgramAccounts(fieldName) {
+  return async (parent, args, context, info) => {
+    const programAddress = fieldName ? parent[fieldName] : args.programAddress;
+    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;
+  };
+}
+
+// src/resolvers/root.ts
+var rootResolvers = {
+  Query: {
+    account: resolveAccount(),
+    block: resolveBlock(),
+    programAccounts: resolveProgramAccounts(),
+    transaction: resolveTransaction()
+  }
+};
+var stringScalarAlias = {
+  __parseLiteral(ast) {
+    if (ast.kind === graphql.Kind.STRING) {
+      return ast.value.toString();
+    }
+    return null;
+  },
+  __parseValue(value) {
+    return value;
+  },
+  __serialize(value) {
+    return 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);
+  }
+};
+var typeTypeResolvers = {
+  AccountEncoding: {
+    BASE_58: "base58",
+    BASE_64: "base64",
+    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"
+  }
+};
+
+// src/resolvers/index.ts
+function createSolanaGraphQLResolvers() {
+  return {
+    ...accountResolvers,
+    ...blockResolvers,
+    ...instructionResolvers,
+    ...rootResolvers,
+    ...transactionResolvers,
+    ...typeTypeResolvers
+  };
+}
+
+// src/schema/account.ts
+var accountTypeDefs = (
+  /* GraphQL */
+  `
+    """
+    Account interface
+    """
+    interface Account {
+        address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+    }
+
+    """
+    Generic base account type
+    """
+    type GenericAccount implements Account {
+        address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+    }
+
+    type NonceAccountFeeCalculator {
+        lamportsPerSignature: String
+    }
+    """
+    A nonce account
+    """
+    type NonceAccount implements Account {
+        address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        authority: Account
+        blockhash: String
+        feeCalculator: NonceAccountFeeCalculator
+    }
+
+    """
+    A lookup table account
+    """
+    type LookupTableAccount implements Account {
+        address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        addresses: [Address]
+        authority: Account
+        deactivationSlot: String
+        lastExtendedSlot: String
+        lastExtendedSlotStartIndex: Int
+    }
+
+    """
+    A mint account
+    """
+    type MintAccount implements Account {
+        address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        decimals: Int
+        freezeAuthority: Account
+        isInitialized: Boolean
+        mintAuthority: Account
+        supply: String
+    }
+
+    """
+    A token account
+    """
+    type TokenAccount implements Account {
+        address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        isNative: Boolean
+        mint: Account
+        owner: Account
+        state: String
+        tokenAmount: TokenAmount
+    }
+
+    type StakeAccountDataMetaAuthorized {
+        staker: Account
+        withdrawer: Account
+    }
+    type StakeAccountDataMetaLockup {
+        custodian: Account
+        epoch: BigInt
+        unixTimestamp: BigInt
+    }
+    type StakeAccountDataMeta {
+        authorized: StakeAccountDataMetaAuthorized
+        lockup: StakeAccountDataMetaLockup
+        rentExemptReserve: String
+    }
+    type StakeAccountDataStakeDelegation {
+        activationEpoch: BigInt
+        deactivationEpoch: BigInt
+        stake: String
+        voter: Account
+        warmupCooldownRate: Int
+    }
+    type StakeAccountDataStake {
+        creditsObserved: BigInt
+        delegation: StakeAccountDataStakeDelegation
+    }
+    """
+    A stake account
+    """
+    type StakeAccount implements Account {
+        address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        meta: StakeAccountDataMeta
+        stake: StakeAccountDataStake
+    }
+
+    type VoteAccountDataAuthorizedVoter {
+        authorizedVoter: Account
+        epoch: BigInt
+    }
+    type VoteAccountDataEpochCredit {
+        credits: String
+        epoch: BigInt
+        previousCredits: String
+    }
+    type VoteAccountDataLastTimestamp {
+        slot: BigInt
+        timestamp: BigInt
+    }
+    type VoteAccountDataVote {
+        confirmationCount: Int
+        slot: BigInt
+    }
+    """
+    A vote account
+    """
+    type VoteAccount implements Account {
+        address: Address
+        data(encoding: AccountEncoding!, dataSlice: DataSlice): String
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        authorizedVoters: [VoteAccountDataAuthorizedVoter]
+        authorizedWithdrawer: Account
+        commission: Int
+        epochCredits: [VoteAccountDataEpochCredit]
+        lastTimestamp: VoteAccountDataLastTimestamp
+        node: Account
+        priorVoters: [Address]
+        rootSlot: BigInt
+        votes: [VoteAccountDataVote]
+    }
+`
+);
+
+// src/schema/block.ts
+var blockTypeDefs = (
+  /* GraphQL */
+  `
+    """
+    A Solana block
+    """
+    type Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: BigInt
+        parentSlot: Slot
+        previousBlockhash: String
+        rewards: [Reward]
+        signatures: [Signature]
+        transactions: [Transaction]
+    }
+`
+);
+
+// src/schema/instruction.ts
+var instructionTypeDefs = (
+  /* GraphQL */
+  `
+    """
+    Transaction instruction interface
+    """
+    interface TransactionInstruction {
+        programId: Address
+    }
+
+    """
+    Generic transaction instruction
+    """
+    type GenericInstruction implements TransactionInstruction {
+        accounts: [Address]
+        data: Base64EncodedBytes
+        programId: Address
+    }
+
+    """
+    AddressLookupTable: CreateLookupTable instruction
+    """
+    type CreateLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        bumpSeed: BigInt # FIXME:*
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+        payerAccount: Account
+        recentSlot: BigInt
+        systemProgram: Account
+    }
+
+    """
+    AddressLookupTable: ExtendLookupTable instruction
+    """
+    type ExtendLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+        newAddresses: [Address]
+        payerAccount: Account
+        systemProgram: Account
+    }
+
+    """
+    AddressLookupTable: FreezeLookupTable instruction
+    """
+    type FreezeLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+    }
+
+    """
+    AddressLookupTable: DeactivateLookupTable instruction
+    """
+    type DeactivateLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+    }
+
+    """
+    AddressLookupTable: CloseLookupTable instruction
+    """
+    type CloseLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+        recipient: Account
+    }
+
+    """
+    BpfLoader: Write instruction
+    """
+    type BpfLoaderWriteInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        bytes: Base64EncodedBytes
+        offset: BigInt # FIXME:*
+    }
+
+    """
+    BpfLoader: Finalize instruction
+    """
+    type BpfLoaderFinalizeInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    """
+    BpfUpgradeableLoader: InitializeBuffer instruction
+    """
+    type BpfUpgradeableLoaderInitializeBufferInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    """
+    BpfUpgradeableLoader: Write instruction
+    """
+    type BpfUpgradeableLoaderWriteInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        bytes: Base64EncodedBytes
+        offset: BigInt # FIXME:*
+    }
+
+    """
+    BpfUpgradeableLoader: DeployWithMaxDataLen instruction
+    """
+    type BpfUpgradeableLoaderDeployWithMaxDataLenInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        bufferAccount: Account
+        clockSysvar: Account
+        maxDataLen: BigInt
+        payerAccount: Account
+        programAccount: Account
+        programDataAccount: Account
+        rentSysvar: Account
+    }
+
+    """
+    BpfUpgradeableLoader: Upgrade instruction
+    """
+    type BpfUpgradeableLoaderUpgradeInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        bufferAccount: Account
+        clockSysvar: Account
+        programAccount: Account
+        programDataAccount: Account
+        rentSysvar: Account
+        spillAccount: Account
+    }
+
+    """
+    BpfUpgradeableLoader: SetAuthority instruction
+    """
+    type BpfUpgradeableLoaderSetAuthorityInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        newAuthority: Account
+    }
+
+    """
+    BpfUpgradeableLoader: SetAuthorityChecked instruction
+    """
+    type BpfUpgradeableLoaderSetAuthorityCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        newAuthority: Account
+    }
+
+    """
+    BpfUpgradeableLoader: Close instruction
+    """
+    type BpfUpgradeableLoaderCloseInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        programAccount: Account
+        recipient: Account
+    }
+
+    """
+    BpfUpgradeableLoader: ExtendProgram instruction
+    """
+    type BpfUpgradeableLoaderExtendProgramInstruction implements TransactionInstruction {
+        programId: Address
+        additionalBytes: BigInt
+        payerAccount: Account
+        programAccount: Account
+        programDataAccount: Account
+        systemProgram: Account
+    }
+
+    """
+    SplAssociatedTokenAccount: Create instruction
+    """
+    type SplAssociatedTokenCreateInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        source: Account
+        systemProgram: Account
+        tokenProgram: Account
+        wallet: Account
+    }
+
+    """
+    SplAssociatedTokenAccount: CreateIdempotent instruction
+    """
+    type SplAssociatedTokenCreateIdempotentInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        source: Account
+        systemProgram: Account
+        tokenProgram: Account
+        wallet: Account
+    }
+
+    """
+    SplAssociatedTokenAccount: RecoverNested instruction
+    """
+    type SplAssociatedTokenRecoverNestedInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        nestedMint: Account
+        nestedOwner: Account
+        nestedSource: Account
+        ownerMint: Account
+        tokenProgram: Account
+        wallet: Account
+    }
+
+    """
+    SplMemo instruction
+    """
+    type SplMemoInstruction implements TransactionInstruction {
+        programId: Address
+        memo: String
+    }
+
+    """
+    SplToken: InitializeMint instruction
+    """
+    type SplTokenInitializeMintInstruction implements TransactionInstruction {
+        programId: Address
+        decimals: BigInt # FIXME:*
+        freezeAuthority: Account
+        mint: Account
+        mintAuthority: Account
+        rentSysvar: Account
+    }
+
+    """
+    SplToken: InitializeMint2 instruction
+    """
+    type SplTokenInitializeMint2Instruction implements TransactionInstruction {
+        programId: Address
+        decimals: BigInt # FIXME:*
+        freezeAuthority: Account
+        mint: Account
+        mintAuthority: Account
+    }
+
+    """
+    SplToken: InitializeAccount instruction
+    """
+    type SplTokenInitializeAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        owner: Account
+        rentSysvar: Account
+    }
+
+    """
+    SplToken: InitializeAccount2 instruction
+    """
+    type SplTokenInitializeAccount2Instruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        owner: Account
+        rentSysvar: Account
+    }
+
+    """
+    SplToken: InitializeAccount3 instruction
+    """
+    type SplTokenInitializeAccount3Instruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        owner: Account
+    }
+
+    """
+    SplToken: InitializeMultisig instruction
+    """
+    type SplTokenInitializeMultisigInstruction implements TransactionInstruction {
+        programId: Address
+        m: BigInt # FIXME:*
+        multisig: Account
+        rentSysvar: Account
+        signers: [Address]
+    }
+
+    """
+    SplToken: InitializeMultisig2 instruction
+    """
+    type SplTokenInitializeMultisig2Instruction implements TransactionInstruction {
+        programId: Address
+        m: BigInt # FIXME:*
+        multisig: Account
+        signers: [Address]
+    }
+
+    """
+    SplToken: Transfer instruction
+    """
+    type SplTokenTransferInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        authority: Account
+        destination: Account
+        multisigAuthority: Account
+        source: Account
+    }
+
+    """
+    SplToken: Approve instruction
+    """
+    type SplTokenApproveInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        delegate: Account
+        multisigOwner: Account
+        owner: Account
+        source: Account
+    }
+
+    """
+    SplToken: Revoke instruction
+    """
+    type SplTokenRevokeInstruction implements TransactionInstruction {
+        programId: Address
+        multisigOwner: Account
+        owner: Account
+        source: Account
+    }
+
+    """
+    SplToken: SetAuthority instruction
+    """
+    type SplTokenSetAuthorityInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        multisigAuthority: Account
+        newAuthority: Account
+    }
+
+    """
+    SplToken: MintTo instruction
+    """
+    type SplTokenMintToInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        amount: String
+        authority: Account
+        mint: Account
+        mintAuthority: Account
+        multisigMintAuthority: Account
+    }
+
+    """
+    SplToken: Burn instruction
+    """
+    type SplTokenBurnInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        amount: String
+        authority: Account
+        mint: Account
+        multisigAuthority: Account
+    }
+
+    """
+    SplToken: CloseAccount instruction
+    """
+    type SplTokenCloseAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        destination: Account
+        multisigOwner: Account
+        owner: Account
+    }
+
+    """
+    SplToken: FreezeAccount instruction
+    """
+    type SplTokenFreezeAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        freezeAuthority: Account
+        mint: Account
+        multisigFreezeAuthority: Account
+    }
+
+    """
+    SplToken: ThawAccount instruction
+    """
+    type SplTokenThawAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        freezeAuthority: Account
+        mint: Account
+        multisigFreezeAuthority: Account
+    }
+
+    """
+    SplToken: TransferChecked instruction
+    """
+    type SplTokenTransferCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        authority: Account
+        decimals: BigInt # FIXME:*
+        destination: Account
+        mint: Account
+        multisigAuthority: Account
+        source: Account
+        tokenAmount: String
+    }
+
+    """
+    SplToken: ApproveChecked instruction
+    """
+    type SplTokenApproveCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        delegate: Account
+        mint: Account
+        multisigOwner: Account
+        owner: Account
+        source: Account
+        tokenAmount: String
+    }
+
+    """
+    SplToken: MintToChecked instruction
+    """
+    type SplTokenMintToCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        mint: Account
+        mintAuthority: Account
+        multisigMintAuthority: Account
+        tokenAmount: String
+    }
+
+    """
+    SplToken: BurnChecked instruction
+    """
+    type SplTokenBurnCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        mint: Account
+        multisigAuthority: Account
+        tokenAmount: String
+    }
+
+    """
+    SplToken: SyncNative instruction
+    """
+    type SplTokenSyncNativeInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    """
+    SplToken: GetAccountDataSize instruction
+    """
+    type SplTokenGetAccountDataSizeInstruction implements TransactionInstruction {
+        programId: Address
+        extensionTypes: [String]
+        mint: Account
+    }
+
+    """
+    SplToken: InitializeImmutableOwner instruction
+    """
+    type SplTokenInitializeImmutableOwnerInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    """
+    SplToken: AmountToUiAmount instruction
+    """
+    type SplTokenAmountToUiAmountInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        mint: Account
+    }
+
+    """
+    SplToken: UiAmountToAmount instruction
+    """
+    type SplTokenUiAmountToAmountInstruction implements TransactionInstruction {
+        programId: Address
+        mint: Account
+        uiAmount: String
+    }
+
+    """
+    SplToken: InitializeMintCloseAuthority instruction
+    """
+    type SplTokenInitializeMintCloseAuthorityInstruction implements TransactionInstruction {
+        programId: Address
+        mint: Account
+        newAuthority: Account
+    }
+
+    # TODO: Extensions!
+    # - TransferFeeExtension
+    # - ConfidentialTransferFeeExtension
+    # - DefaultAccountStateExtension
+    # - Reallocate
+    # - MemoTransferExtension
+    # - CreateNativeMint
+    # - InitializeNonTransferableMint
+    # - InterestBearingMintExtension
+    # - CpiGuardExtension
+    # - InitializePermanentDelegate
+    # - TransferHookExtension
+    # - ConfidentialTransferFeeExtension
+    # - WithdrawExcessLamports
+    # - MetadataPointerExtension
+
+    type Lockup {
+        custodian: Account
+        epoch: BigInt
+        unixTimestamp: BigInt
+    }
+
+    """
+    Stake: Initialize instruction
+    """
+    type StakeInitializeInstructionDataAuthorized {
+        staker: Account
+        withdrawer: Account
+    }
+    type StakeInitializeInstruction implements TransactionInstruction {
+        programId: Address
+        authorized: StakeInitializeInstructionDataAuthorized
+        lockup: Lockup
+        rentSysvar: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: Authorize instruction
+    """
+    type StakeAuthorizeInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Account
+        custodian: Account
+        newAuthority: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: DelegateStake instruction
+    """
+    type StakeDelegateStakeInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Account
+        stakeAccount: Account
+        stakeAuthority: Account
+        stakeConfigAccount: Account
+        stakeHistorySysvar: Account
+        voteAccount: Account
+    }
+
+    """
+    Stake: Split instruction
+    """
+    type StakeSplitInstruction implements TransactionInstruction {
+        programId: Address
+        lamports: BigInt
+        newSplitAccount: Account
+        stakeAccount: Account
+        stakeAuthority: Account
+    }
+
+    """
+    Stake: Withdraw instruction
+    """
+    type StakeWithdrawInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Account
+        destination: Account
+        lamports: BigInt
+        stakeAccount: Account
+        withdrawAuthority: Account
+    }
+
+    """
+    Stake: Deactivate instruction
+    """
+    type StakeDeactivateInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Account
+        stakeAccount: Account
+        stakeAuthority: Account
+    }
+
+    """
+    Stake: SetLockup instruction
+    """
+    type StakeSetLockupInstruction implements TransactionInstruction {
+        programId: Address
+        custodian: Account
+        lockup: Lockup
+        stakeAccount: Account
+    }
+
+    """
+    Stake: Merge instruction
+    """
+    type StakeMergeInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Account
+        destination: Account
+        source: Account
+        stakeAuthority: Account
+        stakeHistorySysvar: Account
+    }
+
+    """
+    Stake: AuthorizeWithSeed instruction
+    """
+    type StakeAuthorizeWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBase: Account
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Account
+        custodian: Account
+        newAuthorized: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: InitializeChecked instruction
+    """
+    type StakeInitializeCheckedInstructionDataAuthorized {
+        staker: Account
+        withdrawer: Account
+    }
+    type StakeInitializeCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        authorized: StakeInitializeCheckedInstructionDataAuthorized
+        lockup: Lockup
+        rentSysvar: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: AuthorizeChecked instruction
+    """
+    type StakeAuthorizeCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Account
+        custodian: Account
+        newAuthority: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: AuthorizeCheckedWithSeed instruction
+    """
+    type StakeAuthorizeCheckedWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBase: Account
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Account
+        custodian: Account
+        newAuthorized: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: SetLockupChecked instruction
+    """
+    type StakeSetLockupCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        custodian: Account
+        lockup: Lockup
+        stakeAccount: Account
+    }
+
+    """
+    Stake: DeactivateDelinquent instruction
+    """
+    type StakeDeactivateDelinquentInstruction implements TransactionInstruction {
+        programId: Address
+        referenceVoteAccount: Account
+        stakeAccount: Account
+        voteAccount: Account
+    }
+
+    """
+    Stake: Redelegate instruction
+    """
+    type StakeRedelegateInstruction implements TransactionInstruction {
+        programId: Address
+        newStakeAccount: Account
+        stakeAccount: Account
+        stakeAuthority: Account
+        stakeConfigAccount: Account
+        voteAccount: Account
+    }
+
+    """
+    System: CreateAccount instruction
+    """
+    type CreateAccountInstruction implements TransactionInstruction {
+        programId: Address
+        lamports: BigInt
+        newAccount: Account
+        owner: Account
+        source: Account
+        space: BigInt
+    }
+
+    """
+    System: Assign instruction
+    """
+    type AssignInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        owner: Account
+    }
+
+    """
+    System: Transfer instruction
+    """
+    type TransferInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        source: Account
+    }
+
+    """
+    System: CreateAccountWithSeed instruction
+    """
+    type CreateAccountWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        base: Account
+        lamports: BigInt
+        owner: Account
+        seed: String
+        space: BigInt
+    }
+
+    """
+    System: AdvanceNonceAccount instruction
+    """
+    type AdvanceNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        nonceAccount: Account
+        nonceAuthority: Account
+        recentBlockhashesSysvar: Account
+    }
+
+    """
+    System: WithdrawNonceAccount instruction
+    """
+    type WithdrawNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        nonceAccount: Account
+        nonceAuthority: Account
+        recentBlockhashesSysvar: Account
+        rentSysvar: Account
+    }
+
+    """
+    System: InitializeNonceAccount instruction
+    """
+    type InitializeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        nonceAccount: Account
+        nonceAuthority: Account
+        recentBlockhashesSysvar: Account
+        rentSysvar: Account
+    }
+
+    """
+    System: AuthorizeNonceAccount instruction
+    """
+    type AuthorizeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        newAuthorized: Account
+        nonceAccount: Account
+        nonceAuthority: Account
+    }
+
+    """
+    System: UpgradeNonceAccount instruction
+    """
+    type UpgradeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        nonceAccount: Account
+        nonceAuthority: Account
+    }
+
+    """
+    System: Allocate instruction
+    """
+    type AllocateInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        space: BigInt
+    }
+
+    """
+    System: AllocateWithSeed instruction
+    """
+    type AllocateWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        base: Address
+        owner: Account
+        seed: String
+        space: BigInt
+    }
+
+    """
+    System: AssignWithSeed instruction
+    """
+    type AssignWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        base: Address
+        owner: Account
+        seed: String
+    }
+
+    """
+    System: TransferWithSeed instruction
+    """
+    type TransferWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        source: Account
+        sourceBase: Address
+        sourceOwner: Account
+        sourceSeed: String
+    }
+
+    """
+    Vote: InitializeAccount instruction
+    """
+    type VoteInitializeAccountInstruction implements TransactionInstruction {
+        programId: Address
+        authorizedVoter: Account
+        authorizedWithdrawer: Account
+        clockSysvar: Account
+        commission: BigInt # FIXME:*
+        node: Account
+        rentSysvar: Account
+        voteAccount: Account
+    }
+
+    """
+    Vote: Authorize instruction
+    """
+    type VoteAuthorizeInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Account
+        newAuthority: Account
+        voteAccount: Account
+    }
+
+    """
+    Vote: AuthorizeWithSeed instruction
+    """
+    type VoteAuthorizeWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBaseKey: String
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Account
+        newAuthority: Account
+        voteAccount: Account
+    }
+
+    """
+    Vote: AuthorizeCheckedWithSeed instruction
+    """
+    type VoteAuthorizeCheckedWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBaseKey: String
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Account
+        newAuthority: Account
+        voteAccount: Account
+    }
+
+    type Vote {
+        hash: String
+        slots: [BigInt]
+        timestamp: BigInt
+    }
+
+    """
+    Vote: Vote instruction
+    """
+    type VoteVoteInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Account
+        slotHashesSysvar: Account
+        vote: Vote
+        voteAccount: Account
+        voteAuthority: Account
+    }
+
+    type VoteStateUpdateLockout {
+        confirmationCount: BigInt # FIXME:*
+        slot: BigInt
+    }
+    type VoteStateUpdate {
+        hash: String
+        lockouts: [VoteStateUpdateLockout]
+        root: BigInt
+        timestamp: BigInt
+    }
+
+    """
+    Vote: UpdateVoteState instruction
+    """
+    type VoteUpdateVoteStateInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    """
+    Vote: UpdateVoteStateSwitch instruction
+    """
+    type VoteUpdateVoteStateSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    """
+    Vote: CompactUpdateVoteState instruction
+    """
+    type VoteCompactUpdateVoteStateInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    """
+    Vote: CompactUpdateVoteStateSwitch instruction
+    """
+    type VoteCompactUpdateVoteStateSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    """
+    Vote: Withdraw instruction
+    """
+    type VoteWithdrawInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        voteAccount: Account
+        withdrawAuthority: Account
+    }
+
+    """
+    Vote: UpdateValidatorIdentity instruction
+    """
+    type VoteUpdateValidatorIdentityInstruction implements TransactionInstruction {
+        programId: Address
+        newValidatorIdentity: Account
+        voteAccount: Account
+        withdrawAuthority: Account
+    }
+
+    """
+    Vote: UpdateCommission instruction
+    """
+    type VoteUpdateCommissionInstruction implements TransactionInstruction {
+        programId: Address
+        commission: BigInt # FIXME:*
+        voteAccount: Account
+        withdrawAuthority: Account
+    }
+
+    """
+    Vote: VoteSwitch instruction
+    """
+    type VoteVoteSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Account
+        hash: String
+        slotHashesSysvar: Account
+        vote: Vote
+        voteAccount: Account
+        voteAuthority: Account
+    }
+
+    """
+    Vote: AuthorizeChecked instruction
+    """
+    type VoteAuthorizeCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Account
+        newAuthority: Account
+        voteAccount: Account
+    }
+`
+);
+
+// src/schema/root.ts
+var rootTypeDefs = (
+  /* GraphQL */
+  `
+    type Query {
+        account(address: Address!, commitment: Commitment, minContextSlot: Slot): Account
+        block(slot: Slot!, commitment: CommitmentWithoutProcessed): Block
+        programAccounts(
+            programAddress: Address!
+            commitment: Commitment
+            filters: [ProgramAccountsFilter]
+            minContextSlot: Slot
+        ): [Account]
+        transaction(signature: Signature!, commitment: CommitmentWithoutProcessed): Transaction
+    }
+
+    schema {
+        query: Query
+    }
+`
+);
+
+// src/schema/transaction.ts
+var transactionTypeDefs = (
+  /* GraphQL */
+  `
+    type TransactionStatusOk {
+        Ok: String
+    }
+    type TransactionStatusErr {
+        Err: String
+    }
+    union TransactionStatus = TransactionStatusOk | TransactionStatusErr
+
+    type TransactionLoadedAddresses {
+        readonly: [String]
+        writable: [String]
+    }
+
+    type TransactionInnerInstruction {
+        index: Int
+        instructions: [TransactionInstruction]
+    }
+
+    type TransactionMeta {
+        computeUnitsConsumed: BigInt
+        err: String
+        fee: BigInt
+        innerInstructions: [TransactionInnerInstruction]
+        loadedAddresses: TransactionLoadedAddresses
+        logMessages: [String]
+        postBalances: [BigInt]
+        postTokenBalances: [TokenBalance]
+        preBalances: [BigInt]
+        preTokenBalances: [TokenBalance]
+        returnData: ReturnData
+        rewards: [Reward]
+        status: TransactionStatus
+    }
+
+    type TransactionMessageAccountKey {
+        pubkey: Address
+        signer: Boolean
+        source: String
+        writable: Boolean
+    }
+
+    type TransactionMessageAddressTableLookup {
+        accountKey: Address
+        readableIndexes: [Int]
+        writableIndexes: [Int]
+    }
+
+    type TransactionMessageHeader {
+        numReadonlySignedAccounts: Int
+        numReadonlyUnsignedAccounts: Int
+        numRequiredSignatures: Int
+    }
+
+    type TransactionMessage {
+        accountKeys: [TransactionMessageAccountKey]
+        addressTableLookups: [TransactionMessageAddressTableLookup]
+        header: TransactionMessageHeader
+        instructions: [TransactionInstruction]
+        recentBlockhash: String
+    }
+
+    """
+    A Solana transaction
+    """
+    type Transaction {
+        blockTime: BigInt
+        data(encoding: TransactionEncoding!): String
+        message: TransactionMessage
+        meta: TransactionMeta
+        signatures: [Signature]
+        slot: Slot
+        version: String
+    }
+`
+);
+
+// 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 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
+        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
+    }
+`
+);
+
+// src/schema/index.ts
+function createSolanaGraphQLTypeDefs() {
+  return [accountTypeDefs, blockTypeDefs, instructionTypeDefs, rootTypeDefs, typeTypeDefs, transactionTypeDefs];
+}
+
+// src/index.ts
+function createRpcGraphQL(rpc, config) {
+  const rpcGraphQLConfig = {
+    maxDataSliceByteRange: config?.maxDataSliceByteRange ?? 200,
+    maxMultipleAccountsBatchSize: config?.maxMultipleAccountsBatchSize ?? 100
+  };
+  const schema$1 = schema.makeExecutableSchema({
+    resolvers: createSolanaGraphQLResolvers(),
+    typeDefs: createSolanaGraphQLTypeDefs()
   });
   return {
-    context,
     async query(source, variableValues) {
-      const result = await graphql.graphql({
-        contextValue: this.context,
-        schema: this.schema,
+      const contextValue = createSolanaGraphQLContext(rpc, rpcGraphQLConfig);
+      return graphql.graphql({
+        contextValue,
+        schema: schema$1,
         source,
         variableValues
       });
-      this.context.cache.flush();
-      return result;
-    },
-    schema
+    }
   };
 }