@solana/rpc-graphql 2.0.0-experimental.8c5ac55 → 2.0.0-experimental.944fbc3

package/dist/index.browser.cjs

@@ -1,89 +1,227 @@
 'use strict';
 
 var graphql = require('graphql');
+var DataLoader = require('dataloader');
+var fastStableStringify = require('fast-stable-stringify');
+var schema = require('@graphql-tools/schema');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var DataLoader__default = /*#__PURE__*/_interopDefault(DataLoader);
+var fastStableStringify__default = /*#__PURE__*/_interopDefault(fastStableStringify);
 
 // src/rpc.ts
 
-// src/cache.ts
-var stringifyValue = (value) => JSON.stringify(value, (_, value2) => {
-  if (typeof value2 === "bigint") {
-    return value2.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 value2;
-});
-var cacheKey = (key, variables) => `GraphQLCache:${stringifyValue(key)}:${stringifyValue(variables)}`;
-function createGraphQLCache() {
-  return {
-    // Browser
-    flush: () => {
-      for (let i = localStorage.length - 1; i >= 0; i--) {
-        const storageKey = localStorage.key(i);
-        if (storageKey && storageKey.startsWith("GraphQLCache:")) {
-          localStorage.removeItem(storageKey);
-        }
+// src/loaders/common/resolve-info.ts
+function onlyPresentFieldRequested(fieldName, info) {
+  if (info && info.fieldNodes[0].selectionSet) {
+    const selectionSet = info.fieldNodes[0].selectionSet;
+    const requestedFields = selectionSet.selections.map((field) => {
+      if (field.kind === "Field") {
+        return field.name.value;
       }
-    },
-    get: (key, variables) => {
-      const value = localStorage.getItem(cacheKey(key, variables));
-      return value === null ? null : parseValue(value);
-    },
-    insert: (key, variables, value) => {
-      localStorage.setItem(cacheKey(key, variables), stringifyValue(value));
+      return null;
+    });
+    if (requestedFields && requestedFields.length === 1 && requestedFields[0] === fieldName) {
+      return true;
     }
-  } ;
+  }
+  return false;
 }
 
-// src/context.ts
-async function resolveAccount({ address, encoding = "jsonParsed", ...config }, cache, rpc) {
-  const requestConfig = { encoding, ...config };
-  const cached = cache.get(address, requestConfig);
-  if (cached !== null) {
-    return cached;
-  }
-  const account = await rpc.getAccountInfo(address, requestConfig).send().then((res) => res.value).catch((e) => {
+// src/loaders/transformers/account.ts
+function transformParsedAccountData(parsedAccountData) {
+  const {
+    parsed: { info: result, type: accountType },
+    program: programName,
+    programId
+  } = parsedAccountData;
+  result.accountType = accountType;
+  result.programId = programId;
+  result.programName = programName;
+  return result;
+}
+function transformLoadedAccount({
+  account,
+  address,
+  encoding
+}) {
+  const [
+    // The account's data, either encoded or parsed.
+    data,
+    // Tells GraphQL which encoding has been returned
+    // by the RPC.
+    responseEncoding
+  ] = Array.isArray(account.data) ? encoding === "jsonParsed" ? (
+    // The requested encoding is jsonParsed,
+    // but the data could not be parsed.
+    // Defaults to base64 encoding.
+    [{ data: account.data[0] }, "base64"]
+  ) : (
+    // The requested encoding is base58,
+    // base64, or base64+zstd.
+    [{ data: account.data[0] }, encoding]
+  ) : (
+    // The account data was returned as an object,
+    // so it was parsed successfully.
+    [transformParsedAccountData(account.data), "jsonParsed"]
+  );
+  account.address = address;
+  account.encoding = responseEncoding;
+  account.ownerProgram = account.owner;
+  return {
+    ...account,
+    ...data
+  };
+}
+
+// src/loaders/account.ts
+function normalizeArgs({
+  address,
+  commitment = "confirmed",
+  dataSlice,
+  encoding = "jsonParsed",
+  minContextSlot
+}) {
+  return { address, commitment, dataSlice, encoding, minContextSlot };
+}
+async function loadAccount(rpc, { address, ...config }) {
+  const account = await rpc.getAccountInfo(address, config).send().then((res) => res.value).catch((e) => {
     throw e;
   });
-  if (account === null) {
-    return {
-      address
-    };
-  }
-  const [data, responseEncoding] = Array.isArray(account.data) ? encoding === "jsonParsed" ? [account.data[0], "base64"] : [account.data[0], encoding] : [account.data, "jsonParsed"];
-  const queryResponse = {
-    ...account,
-    address,
-    data,
-    encoding: responseEncoding
+  return account === null ? { address } : transformLoadedAccount({ account, address, encoding: config.encoding });
+}
+function createAccountBatchLoadFn(rpc) {
+  const resolveAccountUsingRpc = loadAccount.bind(null, rpc);
+  return async (accountQueryArgs) => {
+    return await Promise.all(accountQueryArgs.map(async (args) => await resolveAccountUsingRpc(args)));
+  };
+}
+function createAccountLoader(rpc) {
+  const loader = new DataLoader__default.default(createAccountBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
+  return {
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("address", info)) {
+        return { address: args.address };
+      }
+      return loader.load(normalizeArgs(args));
+    }
   };
-  cache.insert(address, requestConfig, queryResponse);
-  return queryResponse;
 }
-async function resolveBlock({ slot, encoding = "jsonParsed", ...config }, cache, rpc) {
-  const requestConfig = { encoding, ...config };
-  const cached = cache.get(slot, config);
-  if (cached !== null) {
-    return cached;
+
+// src/loaders/transformers/transaction.ts
+function transformParsedInstruction(parsedInstruction) {
+  if ("parsed" in parsedInstruction) {
+    const {
+      parsed: { info: data, type: instructionType },
+      program: programName,
+      programId
+    } = parsedInstruction;
+    return { instructionType, programId, programName, ...data };
+  } else {
+    return parsedInstruction;
   }
-  const block = await rpc.getBlock(slot, requestConfig).send();
-  if (block === null) {
-    return null;
+}
+function transformParsedTransaction(parsedTransaction) {
+  const transactionData = parsedTransaction.transaction;
+  const transactionMeta = parsedTransaction.meta;
+  transactionData.message.instructions = transactionData.message.instructions.map(transformParsedInstruction);
+  transactionMeta.innerInstructions = transactionMeta.innerInstructions.map((innerInstruction) => {
+    innerInstruction.instructions = innerInstruction.instructions.map(transformParsedInstruction);
+    return innerInstruction;
+  });
+  return [transactionData, transactionMeta];
+}
+function transformLoadedTransaction({ encoding, transaction }) {
+  const [transactionData, transactionMeta] = Array.isArray(transaction.transaction) ? (
+    // The requested encoding is base58 or base64.
+    [transaction.transaction[0], transaction.meta]
+  ) : (
+    // The transaction was either partially parsed or
+    // fully JSON-parsed, which will be sorted later.
+    transformParsedTransaction(transaction)
+  );
+  transaction.data = transactionData;
+  transaction.encoding = encoding;
+  transaction.meta = transactionMeta;
+  return transaction;
+}
+
+// src/loaders/transformers/block.ts
+function transformLoadedBlock({
+  encoding,
+  block,
+  transactionDetails
+}) {
+  if (typeof block === "object" && "transactions" in block) {
+    block.transactions = block.transactions.map((transaction) => {
+      if (transactionDetails === "accounts") {
+        return {
+          data: transaction.transaction,
+          meta: transaction.meta,
+          version: transaction.version
+        };
+      } else {
+        return transformLoadedTransaction({ encoding, transaction });
+      }
+    });
   }
-  cache.insert(slot, config, block);
+  block.encoding = encoding;
+  block.transactionDetails = transactionDetails;
   return block;
 }
-async function resolveProgramAccounts({ programAddress, encoding = "jsonParsed", ...config }, cache, rpc) {
-  const requestConfig = { encoding, ...config };
-  const cached = cache.get(programAddress, requestConfig);
-  if (cached !== null) {
-    return cached;
-  }
-  const programAccounts = await rpc.getProgramAccounts(programAddress, requestConfig).send().then((res) => {
+
+// src/loaders/block.ts
+function normalizeArgs2({
+  commitment = "confirmed",
+  encoding = "jsonParsed",
+  slot,
+  transactionDetails = "full"
+}) {
+  return {
+    commitment,
+    encoding,
+    // Always use 0 to avoid silly errors
+    maxSupportedTransactionVersion: 0,
+    slot,
+    transactionDetails
+  };
+}
+async function loadBlock(rpc, { slot, ...config }) {
+  const block = await rpc.getBlock(slot, config).send().catch((e) => {
+    throw e;
+  });
+  return block === null ? { slot } : transformLoadedBlock({ block, encoding: config.encoding, transactionDetails: config.transactionDetails });
+}
+function createBlockBatchLoadFn(rpc) {
+  const resolveBlockUsingRpc = loadBlock.bind(null, rpc);
+  return async (blockQueryArgs) => {
+    return await Promise.all(blockQueryArgs.map(async (args) => await resolveBlockUsingRpc(args)));
+  };
+}
+function createBlockLoader(rpc) {
+  const loader = new DataLoader__default.default(createBlockBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
+  return {
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("slot", info)) {
+        return { slot: args.slot };
+      }
+      return loader.load(normalizeArgs2(args));
+    }
+  };
+}
+function normalizeArgs3({
+  commitment = "confirmed",
+  dataSlice,
+  encoding = "jsonParsed",
+  filters,
+  minContextSlot,
+  programAddress
+}) {
+  return { commitment, dataSlice, encoding, filters, minContextSlot, programAddress };
+}
+async function loadProgramAccounts(rpc, { programAddress, ...config }) {
+  const programAccounts = await rpc.getProgramAccounts(programAddress, config).send().then((res) => {
     if ("value" in res) {
       return res.value;
     }
@@ -91,2112 +229,2413 @@ async function resolveProgramAccounts({ programAddress, encoding = "jsonParsed",
   }).catch((e) => {
     throw e;
   });
-  const queryResponse = programAccounts.map((programAccount2) => {
-    const [data, responseEncoding] = Array.isArray(programAccount2.account.data) ? encoding === "jsonParsed" ? [programAccount2.account.data[0], "base64"] : [programAccount2.account.data[0], encoding] : [programAccount2.account.data, "jsonParsed"];
-    const pubkey = programAccount2.pubkey;
-    const account = { ...programAccount2.account, data, encoding: responseEncoding };
-    return {
-      account,
-      pubkey
-    };
-  });
-  cache.insert(programAddress, requestConfig, queryResponse);
-  return queryResponse;
+  return programAccounts.map(
+    (programAccount) => transformLoadedAccount({
+      account: programAccount.account,
+      address: programAccount.pubkey,
+      encoding: config.encoding
+    })
+  );
 }
-async function resolveTransaction({ signature, encoding = "jsonParsed", ...config }, cache, rpc) {
-  const requestConfig = { encoding, ...config };
-  const cached = cache.get(signature, requestConfig);
-  if (cached !== null) {
-    return cached;
-  }
-  const transaction = await rpc.getTransaction(signature, requestConfig).send();
-  if (transaction === null) {
-    return null;
-  }
-  const [transactionData, responseEncoding, responseFormat] = Array.isArray(transaction.transaction) ? encoding === "jsonParsed" ? [transaction.transaction[0], "base64", "unparsed"] : [transaction.transaction[0], encoding, "unparsed"] : encoding === "jsonParsed" ? [transaction.transaction, encoding, "parsed"] : [transaction.transaction, encoding, "unparsed"];
-  if (transaction.meta) {
-    transaction.meta["format"] = responseFormat;
-  }
-  if (transactionData.message) {
-    transactionData.message["format"] = responseFormat;
-  }
-  const queryResponse = {
-    ...transaction,
-    encoding: responseEncoding,
-    transaction: transactionData
+function createProgramAccountsBatchLoadFn(rpc) {
+  const resolveProgramAccountsUsingRpc = loadProgramAccounts.bind(null, rpc);
+  return async (programAccountsQueryArgs) => {
+    return await Promise.all(
+      programAccountsQueryArgs.map(async (args) => await resolveProgramAccountsUsingRpc(args))
+    );
   };
-  cache.insert(signature, requestConfig, queryResponse);
-  return queryResponse;
 }
-function createSolanaGraphQLContext(rpc) {
-  const cache = createGraphQLCache();
+function createProgramAccountsLoader(rpc) {
+  const loader = new DataLoader__default.default(createProgramAccountsBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
   return {
-    cache,
-    resolveAccount(args) {
-      return resolveAccount(args, this.cache, this.rpc);
-    },
-    resolveBlock(args) {
-      return resolveBlock(args, this.cache, this.rpc);
-    },
-    resolveProgramAccounts(args) {
-      return resolveProgramAccounts(args, this.cache, this.rpc);
-    },
-    resolveTransaction(args) {
-      return resolveTransaction(args, this.cache, this.rpc);
-    },
-    rpc
-  };
-}
-var BigIntScalar = () => new graphql.GraphQLScalarType({
-  name: "BigInt",
-  parseLiteral(ast) {
-    if (ast.kind === graphql.Kind.STRING) {
-      return BigInt(ast.value);
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("programAddress", info)) {
+        return { programAddress: args.programAddress };
+      }
+      return loader.load(normalizeArgs3(args));
     }
-    return null;
-  },
-  parseValue(value) {
-    return BigInt(value);
-  },
-  serialize(value) {
-    return BigInt(value);
-  }
-});
-
-// src/schema/picks.ts
-function boolean() {
-  return { type: graphql.GraphQLBoolean };
-}
-var memoisedBigint;
-function bigint() {
-  if (!memoisedBigint)
-    memoisedBigint = { type: BigIntScalar() };
-  return memoisedBigint;
-}
-function number() {
-  return { type: graphql.GraphQLInt };
-}
-function string() {
-  return { type: graphql.GraphQLString };
+  };
 }
-function type(fieldType) {
+function normalizeArgs4({ commitment = "confirmed", encoding = "jsonParsed", signature }) {
   return {
-    type: fieldType
+    commitment,
+    encoding,
+    // Always use 0 to avoid silly errors
+    maxSupportedTransactionVersion: 0,
+    signature
   };
 }
-function nonNull(fieldType) {
-  return {
-    type: new graphql.GraphQLNonNull(fieldType.type)
+async function loadTransaction(rpc, { signature, ...config }) {
+  const { encoding } = config;
+  const transaction = await rpc.getTransaction(signature, config).send().catch((e) => {
+    throw e;
+  });
+  if (transaction === null) {
+    return null;
+  }
+  if (encoding !== "jsonParsed") {
+    const jsonParsedConfig = { ...config, encoding: "jsonParsed" };
+    const transactionJsonParsed = await rpc.getTransaction(signature, jsonParsedConfig).send().catch((e) => {
+      throw e;
+    });
+    if (transactionJsonParsed === null) {
+      return null;
+    }
+    transaction.meta = transactionJsonParsed.meta;
+  }
+  return transformLoadedTransaction({ encoding, transaction });
+}
+function createTransactionBatchLoadFn(rpc) {
+  const resolveTransactionUsingRpc = loadTransaction.bind(null, rpc);
+  return async (transactionQueryArgs) => {
+    return await Promise.all(transactionQueryArgs.map(async (args) => await resolveTransactionUsingRpc(args)));
   };
 }
-function list(elementType) {
+function createTransactionLoader(rpc) {
+  const loader = new DataLoader__default.default(createTransactionBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
   return {
-    type: new graphql.GraphQLList(elementType.type)
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("signature", info)) {
+        return { signature: args.signature };
+      }
+      return loader.load(normalizeArgs4(args));
+    }
   };
 }
-function object(name, fields) {
+
+// src/context.ts
+function createSolanaGraphQLContext(rpc) {
   return {
-    type: new graphql.GraphQLObjectType({
-      fields,
-      name
-    })
+    loaders: {
+      account: createAccountLoader(rpc),
+      block: createBlockLoader(rpc),
+      programAccounts: createProgramAccountsLoader(rpc),
+      transaction: createTransactionLoader(rpc)
+    },
+    rpc
   };
 }
 
-// src/schema/inputs.ts
-var memoisedAccountEncodingInputType;
-var accountEncodingInputType = () => {
-  if (!memoisedAccountEncodingInputType)
-    memoisedAccountEncodingInputType = new graphql.GraphQLEnumType({
-      name: "AccountEncoding",
-      values: {
-        base58: {
-          value: "base58"
-        },
-        base64: {
-          value: "base64"
-        },
-        base64Zstd: {
-          value: "base64+zstd"
-        },
-        jsonParsed: {
-          value: "jsonParsed"
-        }
-      }
-    });
-  return memoisedAccountEncodingInputType;
+// src/resolvers/account.ts
+var resolveAccount = (fieldName) => {
+  return (parent, args, context, info) => parent[fieldName] === null ? null : context.loaders.account.load({ ...args, address: parent[fieldName] }, info);
 };
-var memoisedBlockTransactionDetailsInputType;
-var blockTransactionDetailsInputType = () => {
-  if (!memoisedBlockTransactionDetailsInputType)
-    memoisedBlockTransactionDetailsInputType = new graphql.GraphQLEnumType({
-      name: "BlockTransactionDetails",
-      values: {
-        accounts: {
-          value: "accounts"
-        },
-        full: {
-          value: "full"
-        },
-        none: {
-          value: "none"
-        },
-        signatures: {
-          value: "signatures"
-        }
+
+// src/schema/account.ts
+var accountTypeDefs = (
+  /* GraphQL */
+  `
+    # Account interface
+    interface Account {
+        address: Address
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+    }
+
+    # An account with base58 encoded data
+    type AccountBase58 implements Account {
+        address: Address
+        data: Base58EncodedBytes
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+    }
+
+    # An account with base64 encoded data
+    type AccountBase64 implements Account {
+        address: Address
+        data: Base64EncodedBytes
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+    }
+
+    # An account with base64+zstd encoded data
+    type AccountBase64Zstd implements Account {
+        address: Address
+        data: Base64ZstdEncodedBytes
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+    }
+
+    # A nonce account
+    type NonceAccountFeeCalculator {
+        lamportsPerSignature: String
+    }
+    type NonceAccount implements Account {
+        address: Address
+        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
+        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
+        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
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        isNative: Boolean
+        mint: Account
+        owner: Account
+        state: String
+        tokenAmount: TokenAmount
+    }
+
+    # A stake account
+    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
+    }
+    type StakeAccount implements Account {
+        address: Address
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        meta: StakeAccountDataMeta
+        stake: StakeAccountDataStake
+    }
+
+    # A vote account
+    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
+    }
+    type VoteAccount implements Account {
+        address: Address
+        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]
+    }
+`
+);
+var accountResolvers = {
+  Account: {
+    __resolveType(account) {
+      if (account.encoding === "base58") {
+        return "AccountBase58";
       }
-    });
-  return memoisedBlockTransactionDetailsInputType;
-};
-var memoisedCommitmentInputType;
-var commitmentInputType = () => {
-  if (!memoisedCommitmentInputType)
-    memoisedCommitmentInputType = new graphql.GraphQLEnumType({
-      name: "Commitment",
-      values: {
-        confirmed: {
-          value: "confirmed"
-        },
-        finalized: {
-          value: "finalized"
-        },
-        processed: {
-          value: "processed"
-        }
+      if (account.encoding === "base64") {
+        return "AccountBase64";
       }
-    });
-  return memoisedCommitmentInputType;
-};
-var memoisedDataSliceInputType;
-var dataSliceInputType = () => {
-  if (!memoisedDataSliceInputType)
-    memoisedDataSliceInputType = new graphql.GraphQLInputObjectType({
-      fields: {
-        length: number(),
-        offset: number()
-      },
-      name: "DataSliceConfig"
-    });
-  return memoisedDataSliceInputType;
-};
-var memoisedMaxSupportedTransactionVersionInputType;
-var maxSupportedTransactionVersionInputType = () => {
-  if (!memoisedMaxSupportedTransactionVersionInputType)
-    memoisedMaxSupportedTransactionVersionInputType = new graphql.GraphQLEnumType({
-      name: "MaxSupportedTransactionVersion",
-      values: {
-        legacy: {
-          value: "legacy"
-        },
-        zero: {
-          value: "0"
-        }
+      if (account.encoding === "base64+zstd") {
+        return "AccountBase64Zstd";
       }
-    });
-  return memoisedMaxSupportedTransactionVersionInputType;
-};
-var memoisedProgramAccountFilterInputType;
-var programAccountFilterInputType = () => {
-  if (!memoisedProgramAccountFilterInputType)
-    memoisedProgramAccountFilterInputType = new graphql.GraphQLInputObjectType({
-      fields: {
-        bytes: bigint(),
-        dataSize: bigint(),
-        encoding: string(),
-        offset: bigint()
-      },
-      name: "ProgramAccountFilter"
-    });
-  return memoisedProgramAccountFilterInputType;
-};
-var memoisedTransactionEncodingInputType;
-var transactionEncodingInputType = () => {
-  if (!memoisedTransactionEncodingInputType)
-    memoisedTransactionEncodingInputType = new graphql.GraphQLEnumType({
-      name: "TransactionEncoding",
-      values: {
-        base58: {
-          value: "base58"
-        },
-        base64: {
-          value: "base64"
-        },
-        json: {
-          value: "json"
-        },
-        jsonParsed: {
-          value: "jsonParsed"
+      if (account.encoding === "jsonParsed") {
+        if (account.programName === "nonce") {
+          return "NonceAccount";
         }
-      }
-    });
-  return memoisedTransactionEncodingInputType;
-};
-var memoisedTokenAmountType;
-var tokenAmountType = () => {
-  if (!memoisedTokenAmountType) {
-    memoisedTokenAmountType = new graphql.GraphQLObjectType({
-      fields: {
-        amount: string(),
-        decimals: number(),
-        uiAmount: bigint(),
-        uiAmountString: string()
-      },
-      name: "TokenAmount"
-    });
-  }
-  return memoisedTokenAmountType;
-};
-var memoisedAccountInterfaceFields;
-var accountInterfaceFields = () => {
-  if (!memoisedAccountInterfaceFields) {
-    memoisedAccountInterfaceFields = {
-      address: string(),
-      encoding: string(),
-      executable: boolean(),
-      lamports: bigint(),
-      rentEpoch: bigint()
-    };
-  }
-  return memoisedAccountInterfaceFields;
-};
-var memoisedAccountInterface;
-var accountInterface = () => {
-  if (!memoisedAccountInterface) {
-    memoisedAccountInterface = new graphql.GraphQLInterfaceType({
-      description: "A Solana account",
-      fields: () => ({
-        ...accountInterfaceFields(),
-        owner: type(accountInterface())
-      }),
-      name: "Account",
-      resolveType(account) {
-        if (account.encoding === "base58") {
-          return "AccountBase58";
+        if (account.accountType === "mint" && account.programName === "spl-token") {
+          return "MintAccount";
         }
-        if (account.encoding === "base64") {
-          return "AccountBase64";
+        if (account.accountType === "account" && account.programName === "spl-token") {
+          return "TokenAccount";
         }
-        if (account.encoding === "base64+zstd") {
-          return "AccountBase64Zstd";
+        if (account.programName === "stake") {
+          return "StakeAccount";
         }
-        if (account.encoding === "jsonParsed") {
-          if (account.data.parsed.type === "mint" && account.data.program === "spl-token") {
-            return "MintAccount";
-          }
-          if (account.data.parsed.type === "account" && account.data.program === "spl-token") {
-            return "TokenAccount";
-          }
-          if (account.data.program === "nonce") {
-            return "NonceAccount";
-          }
-          if (account.data.program === "stake") {
-            return "StakeAccount";
-          }
-          if (account.data.parsed.type === "vote" && account.data.program === "vote") {
-            return "VoteAccount";
-          }
-          if (account.data.parsed.type === "lookupTable" && account.data.program === "address-lookup-table") {
-            return "LookupTableAccount";
-          }
+        if (account.accountType === "vote" && account.programName === "vote") {
+          return "VoteAccount";
+        }
+        if (account.accountType === "lookupTable" && account.programName === "address-lookup-table") {
+          return "LookupTableAccount";
         }
-        return "AccountBase64";
       }
-    });
+      return "AccountBase64";
+    }
+  },
+  AccountBase58: {
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  AccountBase64: {
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  AccountBase64Zstd: {
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  NonceAccount: {
+    authority: resolveAccount("authority"),
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  LookupTableAccount: {
+    authority: resolveAccount("authority"),
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  MintAccount: {
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  TokenAccount: {
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner"),
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  StakeAccountDataMetaAuthorized: {
+    staker: resolveAccount("staker"),
+    withdrawer: resolveAccount("withdrawer")
+  },
+  StakeAccountDataMetaLockup: {
+    custodian: resolveAccount("custodian")
+  },
+  StakeAccountDataStakeDelegation: {
+    voter: resolveAccount("voter")
+  },
+  StakeAccount: {
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  VoteAccountDataAuthorizedVoter: {
+    authorizedVoter: resolveAccount("authorizedVoter")
+  },
+  VoteAccount: {
+    authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
+    node: resolveAccount("nodePubkey"),
+    ownerProgram: resolveAccount("ownerProgram")
   }
-  return memoisedAccountInterface;
 };
-var accountType = (name, description, data) => new graphql.GraphQLObjectType({
-  description,
-  fields: {
-    ...accountInterfaceFields(),
-    data,
-    owner: {
-      args: {
-        commitment: type(commitmentInputType()),
-        dataSlice: type(dataSliceInputType()),
-        encoding: type(accountEncodingInputType()),
-        minContextSlot: bigint()
-      },
-      resolve: (parent, args, context) => context.resolveAccount({ ...args, address: parent.owner }),
-      type: accountInterface()
-    }
-  },
-  interfaces: [accountInterface()],
-  name
-});
-var accountDataJsonParsed = (name, parsedInfoFields) => object(name + "Data", {
-  parsed: object(name + "DataParsed", {
-    info: object(name + "DataParsedInfo", parsedInfoFields),
-    type: string()
-  }),
-  program: string(),
-  space: bigint()
-});
-var memoisedAccountBase58;
-var accountBase58 = () => {
-  if (!memoisedAccountBase58)
-    memoisedAccountBase58 = accountType("AccountBase58", "A Solana account with base58 encoded data", string());
-  return memoisedAccountBase58;
-};
-var memoisedAccountBase64;
-var accountBase64 = () => {
-  if (!memoisedAccountBase64)
-    memoisedAccountBase64 = accountType("AccountBase64", "A Solana account with base64 encoded data", string());
-  return memoisedAccountBase64;
-};
-var memoisedAccountBase64Zstd;
-var accountBase64Zstd = () => {
-  if (!memoisedAccountBase64Zstd)
-    memoisedAccountBase64Zstd = accountType(
-      "AccountBase64Zstd",
-      "A Solana account with base64 encoded data compressed with zstd",
-      string()
-    );
-  return memoisedAccountBase64Zstd;
-};
-var memoisedAccountNonceAccount;
-var accountNonceAccount = () => {
-  if (!memoisedAccountNonceAccount)
-    memoisedAccountNonceAccount = accountType(
-      "NonceAccount",
-      "A nonce account",
-      accountDataJsonParsed("Nonce", {
-        authority: string(),
-        blockhash: string(),
-        feeCalculator: object("NonceFeeCalculator", {
-          lamportsPerSignature: string()
-        })
-      })
-    );
-  return memoisedAccountNonceAccount;
-};
-var memoisedAccountLookupTable;
-var accountLookupTable = () => {
-  if (!memoisedAccountLookupTable)
-    memoisedAccountLookupTable = accountType(
-      "LookupTableAccount",
-      "An address lookup table account",
-      accountDataJsonParsed("LookupTable", {
-        addresses: list(string()),
-        authority: string(),
-        deactivationSlot: string(),
-        lastExtendedSlot: string(),
-        lastExtendedSlotStartIndex: number()
-      })
-    );
-  return memoisedAccountLookupTable;
-};
-var memoisedAccountMint;
-var accountMint = () => {
-  if (!memoisedAccountMint)
-    memoisedAccountMint = accountType(
-      "MintAccount",
-      "An SPL mint",
-      accountDataJsonParsed("Mint", {
-        decimals: number(),
-        freezeAuthority: string(),
-        isInitialized: boolean(),
-        mintAuthority: string(),
-        supply: string()
-      })
-    );
-  return memoisedAccountMint;
-};
-var memoisedAccountTokenAccount;
-var accountTokenAccount = () => {
-  if (!memoisedAccountTokenAccount)
-    memoisedAccountTokenAccount = accountType(
-      "TokenAccount",
-      "An SPL token account",
-      accountDataJsonParsed("TokenAccount", {
-        isNative: boolean(),
-        mint: string(),
-        owner: string(),
-        state: string(),
-        tokenAmount: type(tokenAmountType())
-      })
-    );
-  return memoisedAccountTokenAccount;
+
+// src/schema/block.ts
+var blockTypeDefs = (
+  /* GraphQL */
+  `
+    type TransactionMetaForAccounts {
+        err: String
+        fee: BigInt
+        postBalances: [BigInt]
+        postTokenBalances: [TokenBalance]
+        preBalances: [BigInt]
+        preTokenBalances: [TokenBalance]
+        status: TransactionStatus
+    }
+
+    type TransactionDataForAccounts {
+        accountKeys: [Address]
+        signatures: [String]
+    }
+
+    type BlockTransactionAccounts {
+        meta: TransactionMetaForAccounts
+        data: TransactionDataForAccounts
+        version: String
+    }
+
+    # Block interface
+    interface Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        transactionDetails: String
+    }
+
+    # A block with account transaction details
+    type BlockWithAccounts implements Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        transactions: [BlockTransactionAccounts]
+        transactionDetails: String
+    }
+
+    # A block with full transaction details
+    type BlockWithFull implements Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        transactions: [Transaction]
+        transactionDetails: String
+    }
+
+    # A block with none transaction details
+    type BlockWithNone implements Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        transactionDetails: String
+    }
+
+    # A block with signature transaction details
+    type BlockWithSignatures implements Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        signatures: [String]
+        transactionDetails: String
+    }
+`
+);
+var blockResolvers = {
+  Block: {
+    __resolveType(block) {
+      switch (block.transactionDetails) {
+        case "accounts":
+          return "BlockWithAccounts";
+        case "none":
+          return "BlockWithNone";
+        case "signatures":
+          return "BlockWithSignatures";
+        default:
+          return "BlockWithFull";
+      }
+    }
+  }
 };
-var memoisedAccountStakeAccount;
-var accountStakeAccount = () => {
-  if (!memoisedAccountStakeAccount)
-    memoisedAccountStakeAccount = accountType(
-      "StakeAccount",
-      "A stake account",
-      accountDataJsonParsed("Stake", {
-        meta: object("StakeMeta", {
-          authorized: object("StakeMetaAuthorized", {
-            staker: string(),
-            withdrawer: string()
-          }),
-          lockup: object("StakeMetaLockup", {
-            custodian: string(),
-            epoch: bigint(),
-            unixTimestamp: bigint()
-          }),
-          rentExemptReserve: string()
-        }),
-        stake: object("StakeStake", {
-          creditsObserved: bigint(),
-          delegation: object("StakeStakeDelegation", {
-            activationEpoch: bigint(),
-            deactivationEpoch: bigint(),
-            stake: string(),
-            voter: string(),
-            warmupCooldownRate: number()
-          })
-        })
-      })
-    );
-  return memoisedAccountStakeAccount;
+
+// src/schema/common/inputs.ts
+var inputTypeDefs = (
+  /* GraphQL */
+  `
+    input DataSlice {
+        offset: Int
+        length: Int
+    }
+
+    input ProgramAccountsFilter {
+        bytes: BigInt
+        dataSize: BigInt
+        encoding: AccountEncoding
+        offset: BigInt
+    }
+`
+);
+var inputResolvers = {};
+var scalarTypeDefs = (
+  /* GraphQL */
+  `
+    scalar Address
+    scalar Base58EncodedBytes
+    scalar Base64EncodedBytes
+    scalar Base64ZstdEncodedBytes
+    scalar BigInt
+`
+);
+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 memoisedAccountVoteAccount;
-var accountVoteAccount = () => {
-  if (!memoisedAccountVoteAccount)
-    memoisedAccountVoteAccount = accountType(
-      "VoteAccount",
-      "A vote account",
-      accountDataJsonParsed("Vote", {
-        authorizedVoters: list(
-          object("VoteAuthorizedVoter", {
-            authorizedVoter: string(),
-            epoch: bigint()
-          })
-        ),
-        authorizedWithdrawer: string(),
-        commission: number(),
-        epochCredits: list(
-          object("VoteEpochCredits", {
-            credits: string(),
-            epoch: bigint(),
-            previousCredits: string()
-          })
-        ),
-        lastTimestamp: object("VoteLastTimestamp", {
-          slot: bigint(),
-          timestamp: bigint()
-        }),
-        nodePubkey: string(),
-        priorVoters: list(string()),
-        rootSlot: bigint(),
-        votes: list(
-          object("VoteVote", {
-            confirmationCount: number(),
-            slot: bigint()
-          })
-        )
-      })
-    );
-  return memoisedAccountVoteAccount;
+var scalarResolvers = {
+  Address: stringScalarAlias,
+  Base58EncodedBytes: stringScalarAlias,
+  Base64EncodedBytes: stringScalarAlias,
+  Base64ZstdEncodedBytes: stringScalarAlias,
+  BigInt: {
+    __parseLiteral(ast) {
+      if (ast.kind === graphql.Kind.STRING) {
+        return BigInt(ast.value);
+      }
+      return null;
+    },
+    __parseValue(value) {
+      return BigInt(value);
+    },
+    __serialize(value) {
+      return BigInt(value);
+    }
+  }
 };
-var memoisedAccountTypes;
-var accountTypes = () => {
-  if (!memoisedAccountTypes)
-    memoisedAccountTypes = [
-      accountBase58(),
-      accountBase64(),
-      accountBase64Zstd(),
-      accountNonceAccount(),
-      accountLookupTable(),
-      accountMint(),
-      accountTokenAccount(),
-      accountStakeAccount(),
-      accountVoteAccount()
-    ];
-  return memoisedAccountTypes;
+
+// src/schema/common/types.ts
+var commonTypeDefs = (
+  /* GraphQL */
+  `
+    enum AccountEncoding {
+        BASE_58
+        BASE_64
+        BASE_64_ZSTD
+        PARSED
+    }
+
+    enum BlockTransactionDetails {
+        accounts
+        full
+        none
+        signatures
+    }
+
+    enum Commitment {
+        confirmed
+        finalized
+        processed
+    }
+
+    type ReturnData {
+        data: Base64EncodedBytes
+        programId: Address
+    }
+
+    type Reward {
+        commission: Int
+        lamports: BigInt
+        postBalance: BigInt
+        pubkey: Address
+        rewardType: String
+    }
+
+    type TokenAmount {
+        amount: String
+        decimals: Int
+        uiAmount: BigInt
+        uiAmountString: String
+    }
+
+    type TokenBalance {
+        accountIndex: Int
+        mint: Account
+        owner: Account
+        programId: Address
+        uiTokenAmount: TokenAmount
+    }
+
+    enum TransactionEncoding {
+        BASE_58
+        BASE_64
+        PARSED
+    }
+
+    enum TransactionVersion {
+        LEGACY
+        ZERO
+    }
+`
+);
+var commonResolvers = {
+  AccountEncoding: {
+    BASE_58: "base58",
+    BASE_64: "base64",
+    BASE_64_ZSTD: "base64+zstd",
+    PARSED: "jsonParsed"
+  },
+  TokenBalance: {
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner")
+  },
+  TransactionEncoding: {
+    BASE_58: "base58",
+    BASE_64: "base64",
+    PARSED: "jsonParsed"
+  },
+  TransactionVersion: {
+    LEGACY: "legacy",
+    ZERO: 0
+  }
 };
 
-// src/schema/account/query.ts
-var accountQuery = () => ({
-  account: {
-    args: {
-      address: nonNull(string()),
-      commitment: type(commitmentInputType()),
-      dataSlice: type(dataSliceInputType()),
-      encoding: type(accountEncodingInputType()),
-      minContextSlot: bigint()
-    },
-    resolve: (_parent, args, context) => context.resolveAccount(args),
-    type: accountInterface()
-  }
-});
-var memoisedTokenBalance;
-var tokenBalance = () => {
-  if (!memoisedTokenBalance)
-    memoisedTokenBalance = new graphql.GraphQLObjectType({
-      fields: {
-        accountIndex: number(),
-        mint: string(),
-        owner: string(),
-        programId: string(),
-        uiAmountString: string()
-      },
-      name: "TokenBalance"
-    });
-  return memoisedTokenBalance;
-};
-var memoisedTransactionStatus;
-var transactionStatus = () => {
-  if (!memoisedTransactionStatus)
-    memoisedTransactionStatus = new graphql.GraphQLUnionType({
-      name: "TransactionStatus",
-      types: [
-        new graphql.GraphQLObjectType({
-          fields: {
-            Err: string()
-          },
-          name: "TransactionStatusError"
-        }),
-        new graphql.GraphQLObjectType({
-          fields: {
-            Ok: string()
-          },
-          name: "TransactionStatusOk"
-        })
-      ]
-    });
-  return memoisedTransactionStatus;
-};
-var memoisedReward;
-var reward = () => {
-  if (!memoisedReward)
-    memoisedReward = new graphql.GraphQLObjectType({
-      fields: {
-        commission: number(),
-        lamports: bigint(),
-        postBalance: bigint(),
-        pubkey: string(),
-        rewardType: string()
-      },
-      name: "Reward"
-    });
-  return memoisedReward;
-};
-var memoisedAddressTableLookup;
-var addressTableLookup = () => {
-  if (!memoisedAddressTableLookup)
-    memoisedAddressTableLookup = new graphql.GraphQLObjectType({
-      fields: {
-        accountKey: string(),
-        readableIndexes: list(number()),
-        writableIndexes: list(number())
-      },
-      name: "AddressTableLookup"
-    });
-  return memoisedAddressTableLookup;
-};
-var memoisedReturnData;
-var returnData = () => {
-  if (!memoisedReturnData)
-    memoisedReturnData = new graphql.GraphQLObjectType({
-      fields: {
-        data: string(),
-        programId: string()
-      },
-      name: "ReturnData"
-    });
-  return memoisedReturnData;
-};
-var memoisedTransactionInstruction;
-var transactionInstruction = () => {
-  if (!memoisedTransactionInstruction)
-    memoisedTransactionInstruction = new graphql.GraphQLObjectType({
-      fields: {
-        accounts: list(number()),
-        data: string(),
-        programIdIndex: number()
-      },
-      name: "TransactionInstruction"
-    });
-  return memoisedTransactionInstruction;
-};
-var memoisedTransactionMetaLoadedAddresses;
-var transactionMetaLoadedAddresses = () => {
-  if (!memoisedTransactionMetaLoadedAddresses)
-    memoisedTransactionMetaLoadedAddresses = new graphql.GraphQLObjectType({
-      fields: {
-        readonly: list(string()),
-        // Base58 encoded addresses
-        writable: list(string())
-        // Base58 encoded addresses
-      },
-      name: "TransactionMetaLoadedAddresses"
-    });
-  return memoisedTransactionMetaLoadedAddresses;
-};
-var memoisedParsedTransactionInstructionInterface;
-var parsedTransactionInstructionInterface = () => {
-  if (!memoisedParsedTransactionInstructionInterface)
-    memoisedParsedTransactionInstructionInterface = new graphql.GraphQLInterfaceType({
-      fields: {
-        programId: string()
-      },
-      name: "ParsedTransactionInstruction",
-      resolveType(instruction) {
-        if (instruction.program === "address-lookup-table") {
-          if (instruction.info.type === "createLookupTable") {
+// 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
+    type CreateLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        bumpSeed: BigInt # FIXME:*
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+        payerAccount: Account
+        recentSlot: BigInt
+        systemProgram: Account
+    }
+
+    # AddressLookupTable: ExtendLookupTable
+    type ExtendLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+        newAddresses: [Address]
+        payerAccount: Account
+        systemProgram: Account
+    }
+
+    # AddressLookupTable: FreezeLookupTable
+    type FreezeLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+    }
+
+    # AddressLookupTable: DeactivateLookupTable
+    type DeactivateLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+    }
+
+    # AddressLookupTable: CloseLookupTable
+    type CloseLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+        recipient: Account
+    }
+
+    # BpfLoader: Write
+    type BpfLoaderWriteInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        bytes: Base64EncodedBytes
+        offset: BigInt # FIXME:*
+    }
+
+    # BpfLoader: Finalize
+    type BpfLoaderFinalizeInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    # BpfUpgradeableLoader: InitializeBuffer
+    type BpfUpgradeableLoaderInitializeBufferInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    # BpfUpgradeableLoader: Write
+    type BpfUpgradeableLoaderWriteInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        bytes: Base64EncodedBytes
+        offset: BigInt # FIXME:*
+    }
+
+    # BpfUpgradeableLoader: DeployWithMaxDataLen
+    type BpfUpgradeableLoaderDeployWithMaxDataLenInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        bufferAccount: Account
+        clockSysvar: Address
+        maxDataLen: BigInt
+        payerAccount: Account
+        programAccount: Account
+        programDataAccount: Account
+        rentSysvar: Address
+    }
+
+    # BpfUpgradeableLoader: Upgrade
+    type BpfUpgradeableLoaderUpgradeInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        bufferAccount: Account
+        clockSysvar: Address
+        programAccount: Account
+        programDataAccount: Account
+        rentSysvar: Address
+        spillAccount: Account
+    }
+
+    # BpfUpgradeableLoader: SetAuthority
+
+    type BpfUpgradeableLoaderSetAuthorityInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        newAuthority: Account
+    }
+
+    # BpfUpgradeableLoader: SetAuthorityChecked
+    type BpfUpgradeableLoaderSetAuthorityCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        newAuthority: Account
+    }
+
+    # BpfUpgradeableLoader: Close
+    type BpfUpgradeableLoaderCloseInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        programAccount: Account
+        recipient: Account
+    }
+
+    # BpfUpgradeableLoader: ExtendProgram
+    type BpfUpgradeableLoaderExtendProgramInstruction implements TransactionInstruction {
+        programId: Address
+        additionalBytes: BigInt
+        payerAccount: Account
+        programAccount: Account
+        programDataAccount: Account
+        systemProgram: Account
+    }
+
+    # SplAssociatedTokenAccount: Create
+    type SplAssociatedTokenCreateInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Address
+        source: Account
+        systemProgram: Account
+        tokenProgram: Account
+        wallet: Account
+    }
+
+    # SplAssociatedTokenAccount: CreateIdempotent
+    type SplAssociatedTokenCreateIdempotentInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Address
+        source: Account
+        systemProgram: Account
+        tokenProgram: Account
+        wallet: Account
+    }
+
+    # SplAssociatedTokenAccount: RecoverNested
+    type SplAssociatedTokenRecoverNestedInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        nestedMint: Account
+        nestedOwner: Account
+        nestedSource: Account
+        ownerMint: Account
+        tokenProgram: Account
+        wallet: Account
+    }
+
+    # SplMemo
+    type SplMemoInstruction implements TransactionInstruction {
+        programId: Address
+        data: String
+    }
+
+    # SplToken: InitializeMint
+    type SplTokenInitializeMintInstruction implements TransactionInstruction {
+        programId: Address
+        decimals: BigInt # FIXME:*
+        freezeAuthority: Account
+        mint: Account
+        mintAuthority: Account
+        rentSysvar: Address
+    }
+
+    # SplToken: InitializeMint2
+    type SplTokenInitializeMint2Instruction implements TransactionInstruction {
+        programId: Address
+        decimals: BigInt # FIXME:*
+        freezeAuthority: Account
+        mint: Account
+        mintAuthority: Account
+    }
+
+    # SplToken: InitializeAccount
+    type SplTokenInitializeAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        owner: Account
+        rentSysvar: Address
+    }
+
+    # SplToken: InitializeAccount2
+    type SplTokenInitializeAccount2Instruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        owner: Account
+        rentSysvar: Address
+    }
+
+    # SplToken: InitializeAccount3
+    type SplTokenInitializeAccount3Instruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        owner: Account
+    }
+
+    # SplToken: InitializeMultisig
+    type SplTokenInitializeMultisigInstruction implements TransactionInstruction {
+        programId: Address
+        m: BigInt # FIXME:*
+        multisig: Account
+        rentSysvar: Address
+        signers: [Address]
+    }
+
+    # SplToken: InitializeMultisig2
+    type SplTokenInitializeMultisig2Instruction implements TransactionInstruction {
+        programId: Address
+        m: BigInt # FIXME:*
+        multisig: Account
+        signers: [Address]
+    }
+
+    # SplToken: Transfer
+    type SplTokenTransferInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        authority: Account
+        destination: Account
+        multisigAuthority: Account
+        source: Account
+    }
+
+    # SplToken: Approve
+    type SplTokenApproveInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        delegate: Account
+        multisigOwner: Account
+        owner: Account
+        source: Account
+    }
+
+    # SplToken: Revoke
+    type SplTokenRevokeInstruction implements TransactionInstruction {
+        programId: Address
+        multisigOwner: Account
+        owner: Account
+        source: Account
+    }
+
+    # SplToken: SetAuthority
+    type SplTokenSetAuthorityInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        multisigAuthority: Account
+        newAuthority: Account
+    }
+
+    # SplToken: MintTo
+    type SplTokenMintToInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        amount: String
+        authority: Account
+        mint: Account
+        mintAuthority: Account
+        multisigMintAuthority: Account
+    }
+
+    # SplToken: Burn
+    type SplTokenBurnInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        amount: String
+        authority: Account
+        mint: Account
+        multisigAuthority: Account
+    }
+
+    # SplToken: CloseAccount
+    type SplTokenCloseAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        destination: Account
+        multisigOwner: Account
+        owner: Account
+    }
+
+    # SplToken: FreezeAccount
+    type SplTokenFreezeAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        freezeAuthority: Account
+        mint: Account
+        multisigFreezeAuthority: Account
+    }
+
+    # SplToken: ThawAccount
+    type SplTokenThawAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        freezeAuthority: Account
+        mint: Account
+        multisigFreezeAuthority: Account
+    }
+
+    # SplToken: TransferChecked
+    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
+    type SplTokenApproveCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        delegate: Account
+        mint: Account
+        multisigOwner: Account
+        owner: Account
+        source: Account
+        tokenAmount: String
+    }
+
+    # SplToken: MintToChecked
+    type SplTokenMintToCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        mint: Account
+        mintAuthority: Account
+        multisigMintAuthority: Account
+        tokenAmount: String
+    }
+
+    # SplToken: BurnChecked
+    type SplTokenBurnCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        mint: Account
+        multisigAuthority: Account
+        tokenAmount: String
+    }
+
+    # SplToken: SyncNative
+    type SplTokenSyncNativeInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    # SplToken: GetAccountDataSize
+    type SplTokenGetAccountDataSizeInstruction implements TransactionInstruction {
+        programId: Address
+        extensionTypes: [String]
+        mint: Account
+    }
+
+    # SplToken: InitializeImmutableOwner
+    type SplTokenInitializeImmutableOwnerInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    # SplToken: AmountToUiAmount
+    type SplTokenAmountToUiAmountInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        mint: Account
+    }
+
+    # SplToken: UiAmountToAmount
+    type SplTokenUiAmountToAmountInstruction implements TransactionInstruction {
+        programId: Address
+        mint: Account
+        uiAmount: String
+    }
+
+    # SplToken: InitializeMintCloseAuthority
+    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
+    type StakeInitializeInstructionDataAuthorized {
+        staker: Account
+        withdrawer: Account
+    }
+    type StakeInitializeInstruction implements TransactionInstruction {
+        programId: Address
+        authorized: StakeInitializeInstructionDataAuthorized
+        lockup: Lockup
+        rentSysvar: Address
+        stakeAccount: Account
+    }
+
+    # Stake: Authorize
+    type StakeAuthorizeInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Address
+        custodian: Account
+        newAuthority: Account
+        stakeAccount: Account
+    }
+
+    # Stake: DelegateStake
+    type StakeDelegateStakeInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        stakeAccount: Account
+        stakeAuthority: Account
+        stakeConfigAccount: Account
+        stakeHistorySysvar: Address
+        voteAccount: Account
+    }
+
+    # Stake: Split
+    type StakeSplitInstruction implements TransactionInstruction {
+        programId: Address
+        lamports: BigInt
+        newSplitAccount: Account
+        stakeAccount: Account
+        stakeAuthority: Account
+    }
+
+    # Stake: Withdraw
+    type StakeWithdrawInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        destination: Account
+        lamports: BigInt
+        stakeAccount: Account
+        withdrawAuthority: Account
+    }
+
+    # Stake: Deactivate
+    type StakeDeactivateInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        stakeAccount: Account
+        stakeAuthority: Account
+    }
+
+    # Stake: SetLockup
+    type StakeSetLockupInstruction implements TransactionInstruction {
+        programId: Address
+        custodian: Account
+        lockup: Lockup
+        stakeAccount: Account
+    }
+
+    # Stake: Merge
+    type StakeMergeInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        destination: Account
+        source: Account
+        stakeAuthority: Account
+        stakeHistorySysvar: Address
+    }
+
+    # Stake: AuthorizeWithSeed
+    type StakeAuthorizeWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBase: Account
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Address
+        custodian: Account
+        newAuthorized: Account
+        stakeAccount: Account
+    }
+
+    # Stake: InitializeChecked
+    type StakeInitializeCheckedInstructionDataAuthorized {
+        staker: Account
+        withdrawer: Account
+    }
+    type StakeInitializeCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        authorized: StakeInitializeCheckedInstructionDataAuthorized
+        lockup: Lockup
+        rentSysvar: Address
+        stakeAccount: Account
+    }
+
+    # Stake: AuthorizeChecked
+    type StakeAuthorizeCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Address
+        custodian: Account
+        newAuthority: Account
+        stakeAccount: Account
+    }
+
+    # Stake: AuthorizeCheckedWithSeed
+    type StakeAuthorizeCheckedWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBase: Account
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Address
+        custodian: Account
+        newAuthorized: Account
+        stakeAccount: Account
+    }
+
+    # Stake: SetLockupChecked
+    type StakeSetLockupCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        custodian: Account
+        lockup: Lockup
+        stakeAccount: Account
+    }
+
+    # Stake: DeactivateDelinquent
+    type StakeDeactivateDelinquentInstruction implements TransactionInstruction {
+        programId: Address
+        referenceVoteAccount: Account
+        stakeAccount: Account
+        voteAccount: Account
+    }
+
+    # Stake: Redelegate
+    type StakeRedelegateInstruction implements TransactionInstruction {
+        programId: Address
+        newStakeAccount: Account
+        stakeAccount: Account
+        stakeAuthority: Account
+        stakeConfigAccount: Account
+        voteAccount: Account
+    }
+
+    # System: CreateAccount
+    type CreateAccountInstruction implements TransactionInstruction {
+        programId: Address
+        lamports: BigInt
+        newAccount: Account
+        owner: Account
+        source: Account
+        space: BigInt
+    }
+
+    # System: Assign
+    type AssignInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        owner: Account
+    }
+
+    # System: Transfer
+    type TransferInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        source: Account
+    }
+
+    # System: CreateAccountWithSeed
+    type CreateAccountWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        base: Account
+        lamports: BigInt
+        owner: Account
+        seed: String
+        space: BigInt
+    }
+
+    # System: AdvanceNonceAccount
+    type AdvanceNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        nonceAccount: Account
+        nonceAuthority: Account
+        recentBlockhashesSysvar: Address
+    }
+
+    # System: WithdrawNonceAccount
+    type WithdrawNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        nonceAccount: Account
+        nonceAuthority: Account
+        recentBlockhashesSysvar: Address
+        rentSysvar: Address
+    }
+
+    # System: InitializeNonceAccount
+    type InitializeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        nonceAccount: Account
+        nonceAuthority: Account
+        recentBlockhashesSysvar: Address
+        rentSysvar: Address
+    }
+
+    # System: AuthorizeNonceAccount
+    type AuthorizeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        newAuthorized: Account
+        nonceAccount: Account
+        nonceAuthority: Account
+    }
+
+    # System: UpgradeNonceAccount
+    type UpgradeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        nonceAccount: Account
+        nonceAuthority: Account
+    }
+
+    # System: Allocate
+    type AllocateInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        space: BigInt
+    }
+
+    # System: AllocateWithSeed
+    type AllocateWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        base: Address
+        owner: Account
+        seed: String
+        space: BigInt
+    }
+
+    # System: AssignWithSeed
+    type AssignWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        base: Address
+        owner: Account
+        seed: String
+    }
+
+    # System: TransferWithSeed
+    type TransferWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        source: Account
+        sourceBase: Address
+        sourceOwner: Account
+        sourceSeed: String
+    }
+
+    # Vote: InitializeAccount
+    type VoteInitializeAccountInstruction implements TransactionInstruction {
+        programId: Address
+        authorizedVoter: Account
+        authorizedWithdrawer: Account
+        clockSysvar: Address
+        commission: BigInt # FIXME:*
+        node: Account
+        rentSysvar: Address
+        voteAccount: Account
+    }
+
+    # Vote: Authorize
+    type VoteAuthorizeInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Address
+        newAuthority: Account
+        voteAccount: Account
+    }
+
+    # Vote: AuthorizeWithSeed
+    type VoteAuthorizeWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBaseKey: String
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Address
+        newAuthority: Account
+        voteAccount: Account
+    }
+
+    # Vote: AuthorizeCheckedWithSeed
+    type VoteAuthorizeCheckedWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBaseKey: String
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Address
+        newAuthority: Account
+        voteAccount: Account
+    }
+
+    type Vote {
+        hash: String
+        slots: [BigInt]
+        timestamp: BigInt
+    }
+
+    # Vote: Vote
+    type VoteVoteInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        slotHashesSysvar: Address
+        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
+    type VoteUpdateVoteStateInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    # Vote: UpdateVoteStateSwitch
+    type VoteUpdateVoteStateSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    # Vote: CompactUpdateVoteState
+    type VoteCompactUpdateVoteStateInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    # Vote: CompactUpdateVoteStateSwitch
+    type VoteCompactUpdateVoteStateSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    # Vote: Withdraw
+    type VoteWithdrawInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        voteAccount: Account
+        withdrawAuthority: Account
+    }
+
+    # Vote: UpdateValidatorIdentity
+    type VoteUpdateValidatorIdentityInstruction implements TransactionInstruction {
+        programId: Address
+        newValidatorIdentity: Account
+        voteAccount: Account
+        withdrawAuthority: Account
+    }
+
+    # Vote: UpdateCommission
+    type VoteUpdateCommissionInstruction implements TransactionInstruction {
+        programId: Address
+        commission: BigInt # FIXME:*
+        voteAccount: Account
+        withdrawAuthority: Account
+    }
+
+    # Vote: VoteSwitch
+    type VoteVoteSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        hash: String
+        slotHashesSysvar: Address
+        vote: Vote
+        voteAccount: Account
+        voteAuthority: Account
+    }
+
+    # Vote: AuthorizeChecked
+    type VoteAuthorizeCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Address
+        newAuthority: Account
+        voteAccount: Account
+    }
+`
+);
+var instructionResolvers = {
+  TransactionInstruction: {
+    __resolveType(instruction) {
+      if (instruction.programName) {
+        if (instruction.programName === "address-lookup-table") {
+          if (instruction.instructionType === "createLookupTable") {
             return "CreateLookupTableInstruction";
           }
-          if (instruction.info.type === "freezeLookupTable") {
+          if (instruction.instructionType === "freezeLookupTable") {
             return "FreezeLookupTableInstruction";
           }
-          if (instruction.info.type === "extendLookupTable") {
+          if (instruction.instructionType === "extendLookupTable") {
             return "ExtendLookupTableInstruction";
           }
-          if (instruction.info.type === "deactivateLookupTable") {
+          if (instruction.instructionType === "deactivateLookupTable") {
             return "DeactivateLookupTableInstruction";
           }
-          if (instruction.info.type === "closeLookupTable") {
+          if (instruction.instructionType === "closeLookupTable") {
             return "CloseLookupTableInstruction";
           }
         }
-        if (instruction.program === "bpf-loader") {
-          if (instruction.info.type === "write") {
+        if (instruction.programName === "bpf-loader") {
+          if (instruction.instructionType === "write") {
             return "BpfLoaderWriteInstruction";
           }
-          if (instruction.info.type === "finalize") {
+          if (instruction.instructionType === "finalize") {
             return "BpfLoaderFinalizeInstruction";
           }
         }
-        if (instruction.program === "bpf-upgradeable-loader") {
-          if (instruction.info.type === "initializeBuffer") {
+        if (instruction.programName === "bpf-upgradeable-loader") {
+          if (instruction.instructionType === "initializeBuffer") {
             return "BpfUpgradeableLoaderInitializeBufferInstruction";
           }
-          if (instruction.info.type === "write") {
+          if (instruction.instructionType === "write") {
             return "BpfUpgradeableLoaderWriteInstruction";
           }
-          if (instruction.info.type === "deployWithMaxDataLen") {
+          if (instruction.instructionType === "deployWithMaxDataLen") {
             return "BpfUpgradeableLoaderDeployWithMaxDataLenInstruction";
           }
-          if (instruction.info.type === "upgrade") {
+          if (instruction.instructionType === "upgrade") {
             return "BpfUpgradeableLoaderUpgradeInstruction";
           }
-          if (instruction.info.type === "setAuthority") {
+          if (instruction.instructionType === "setAuthority") {
             return "BpfUpgradeableLoaderSetAuthorityInstruction";
           }
-          if (instruction.info.type === "setAuthorityChecked") {
+          if (instruction.instructionType === "setAuthorityChecked") {
             return "BpfUpgradeableLoaderSetAuthorityCheckedInstruction";
           }
-          if (instruction.info.type === "close") {
+          if (instruction.instructionType === "close") {
             return "BpfUpgradeableLoaderCloseInstruction";
           }
-          if (instruction.info.type === "extendProgram") {
+          if (instruction.instructionType === "extendProgram") {
             return "BpfUpgradeableLoaderExtendProgramInstruction";
           }
         }
-        if (instruction.program === "spl-associated-token-account") {
-          if (instruction.info.type === "create") {
+        if (instruction.programName === "spl-associated-token-account") {
+          if (instruction.instructionType === "create") {
             return "SplAssociatedTokenCreateInstruction";
           }
-          if (instruction.info.type === "createIdempotent") {
+          if (instruction.instructionType === "createIdempotent") {
             return "SplAssociatedTokenCreateIdempotentInstruction";
           }
-          if (instruction.info.type === "recoverNested") {
+          if (instruction.instructionType === "recoverNested") {
             return "SplAssociatedTokenRecoverNestedInstruction";
           }
         }
-        if (instruction.program === "spl-memo") {
+        if (instruction.programName === "spl-memo") {
           return "SplMemoInstruction";
         }
-        if (instruction.program === "spl-token") {
-          if (instruction.info.type === "initializeMint") {
+        if (instruction.programName === "spl-token") {
+          if (instruction.instructionType === "initializeMint") {
             return "SplTokenInitializeMintInstruction";
           }
-          if (instruction.info.type === "initializeMint2") {
+          if (instruction.instructionType === "initializeMint2") {
             return "SplTokenInitializeMint2Instruction";
           }
-          if (instruction.info.type === "initializeAccount") {
+          if (instruction.instructionType === "initializeAccount") {
             return "SplTokenInitializeAccountInstruction";
           }
-          if (instruction.info.type === "initializeAccount2") {
+          if (instruction.instructionType === "initializeAccount2") {
             return "SplTokenInitializeAccount2Instruction";
           }
-          if (instruction.info.type === "initializeAccount3") {
+          if (instruction.instructionType === "initializeAccount3") {
             return "SplTokenInitializeAccount3Instruction";
           }
-          if (instruction.info.type === "initializeMultisig") {
+          if (instruction.instructionType === "initializeMultisig") {
             return "SplTokenInitializeMultisigInstruction";
           }
-          if (instruction.info.type === "initializeMultisig2") {
+          if (instruction.instructionType === "initializeMultisig2") {
             return "SplTokenInitializeMultisig2Instruction";
           }
-          if (instruction.info.type === "transfer") {
+          if (instruction.instructionType === "transfer") {
             return "SplTokenTransferInstruction";
           }
-          if (instruction.info.type === "approve") {
+          if (instruction.instructionType === "approve") {
             return "SplTokenApproveInstruction";
           }
-          if (instruction.info.type === "revoke") {
+          if (instruction.instructionType === "revoke") {
             return "SplTokenRevokeInstruction";
           }
-          if (instruction.info.type === "setAuthority") {
+          if (instruction.instructionType === "setAuthority") {
             return "SplTokenSetAuthorityInstruction";
           }
-          if (instruction.info.type === "mintTo") {
+          if (instruction.instructionType === "mintTo") {
             return "SplTokenMintToInstruction";
           }
-          if (instruction.info.type === "burn") {
+          if (instruction.instructionType === "burn") {
             return "SplTokenBurnInstruction";
           }
-          if (instruction.info.type === "closeAccount") {
+          if (instruction.instructionType === "closeAccount") {
             return "SplTokenCloseAccountInstruction";
           }
-          if (instruction.info.type === "freezeAccount") {
+          if (instruction.instructionType === "freezeAccount") {
             return "SplTokenFreezeAccountInstruction";
           }
-          if (instruction.info.type === "thawAccount") {
+          if (instruction.instructionType === "thawAccount") {
             return "SplTokenThawAccountInstruction";
           }
-          if (instruction.info.type === "transferChecked") {
+          if (instruction.instructionType === "transferChecked") {
             return "SplTokenTransferCheckedInstruction";
           }
-          if (instruction.info.type === "approveChecked") {
+          if (instruction.instructionType === "approveChecked") {
             return "SplTokenApproveCheckedInstruction";
           }
-          if (instruction.info.type === "mintToChecked") {
+          if (instruction.instructionType === "mintToChecked") {
             return "SplTokenMintToCheckedInstruction";
           }
-          if (instruction.info.type === "burnChecked") {
+          if (instruction.instructionType === "burnChecked") {
             return "SplTokenBurnCheckedInstruction";
           }
-          if (instruction.info.type === "syncNative") {
+          if (instruction.instructionType === "syncNative") {
             return "SplTokenSyncNativeInstruction";
           }
-          if (instruction.info.type === "getAccountDataSize") {
+          if (instruction.instructionType === "getAccountDataSize") {
             return "SplTokenGetAccountDataSizeInstruction";
           }
-          if (instruction.info.type === "initializeImmutableOwner") {
+          if (instruction.instructionType === "initializeImmutableOwner") {
             return "SplTokenInitializeImmutableOwnerInstruction";
           }
-          if (instruction.info.type === "amountToUiAmount") {
+          if (instruction.instructionType === "amountToUiAmount") {
             return "SplTokenAmountToUiAmountInstruction";
           }
-          if (instruction.info.type === "uiAmountToAmount") {
+          if (instruction.instructionType === "uiAmountToAmount") {
             return "SplTokenUiAmountToAmountInstruction";
           }
-          if (instruction.info.type === "initializeMintCloseAuthority") {
+          if (instruction.instructionType === "initializeMintCloseAuthority") {
             return "SplTokenInitializeMintCloseAuthorityInstruction";
           }
         }
-        if (instruction.program === "stake") {
-          if (instruction.info.type === "initialize") {
+        if (instruction.programName === "stake") {
+          if (instruction.instructionType === "initialize") {
             return "StakeInitializeInstruction";
           }
-          if (instruction.info.type === "authorize") {
+          if (instruction.instructionType === "authorize") {
             return "StakeAuthorizeInstruction";
           }
-          if (instruction.info.type === "delegate") {
+          if (instruction.instructionType === "delegate") {
             return "StakeDelegateStakeInstruction";
           }
-          if (instruction.info.type === "split") {
+          if (instruction.instructionType === "split") {
             return "StakeSplitInstruction";
           }
-          if (instruction.info.type === "withdraw") {
+          if (instruction.instructionType === "withdraw") {
             return "StakeWithdrawInstruction";
           }
-          if (instruction.info.type === "deactivate") {
+          if (instruction.instructionType === "deactivate") {
             return "StakeDeactivateInstruction";
           }
-          if (instruction.info.type === "setLockup") {
+          if (instruction.instructionType === "setLockup") {
             return "StakeSetLockupInstruction";
           }
-          if (instruction.info.type === "merge") {
+          if (instruction.instructionType === "merge") {
             return "StakeMergeInstruction";
           }
-          if (instruction.info.type === "authorizeWithSeed") {
+          if (instruction.instructionType === "authorizeWithSeed") {
             return "StakeAuthorizeWithSeedInstruction";
           }
-          if (instruction.info.type === "initializeChecked") {
+          if (instruction.instructionType === "initializeChecked") {
             return "StakeInitializeCheckedInstruction";
           }
-          if (instruction.info.type === "authorizeChecked") {
+          if (instruction.instructionType === "authorizeChecked") {
             return "StakeAuthorizeCheckedInstruction";
           }
-          if (instruction.info.type === "authorizeCheckedWithSeed") {
+          if (instruction.instructionType === "authorizeCheckedWithSeed") {
             return "StakeAuthorizeCheckedWithSeedInstruction";
           }
-          if (instruction.info.type === "setLockupChecked") {
+          if (instruction.instructionType === "setLockupChecked") {
             return "StakeSetLockupCheckedInstruction";
           }
-          if (instruction.info.type === "deactivateDelinquent") {
+          if (instruction.instructionType === "deactivateDelinquent") {
             return "StakeDeactivateDelinquentInstruction";
           }
-          if (instruction.info.type === "redelegate") {
+          if (instruction.instructionType === "redelegate") {
             return "StakeRedelegateInstruction";
           }
         }
-        if (instruction.program === "system") {
-          if (instruction.info.type === "createAccount") {
+        if (instruction.programName === "system") {
+          if (instruction.instructionType === "createAccount") {
             return "CreateAccountInstruction";
           }
-          if (instruction.info.type === "assign") {
+          if (instruction.instructionType === "assign") {
             return "AssignInstruction";
           }
-          if (instruction.info.type === "transfer") {
+          if (instruction.instructionType === "transfer") {
             return "TransferInstruction";
           }
-          if (instruction.info.type === "createAccountWithSeed") {
+          if (instruction.instructionType === "createAccountWithSeed") {
             return "CreateAccountWithSeedInstruction";
           }
-          if (instruction.info.type === "advanceNonceAccount") {
+          if (instruction.instructionType === "advanceNonceAccount") {
             return "AdvanceNonceAccountInstruction";
           }
-          if (instruction.info.type === "withdrawNonceAccount") {
+          if (instruction.instructionType === "withdrawNonceAccount") {
             return "WithdrawNonceAccountInstruction";
           }
-          if (instruction.info.type === "initializeNonceAccount") {
+          if (instruction.instructionType === "initializeNonceAccount") {
             return "InitializeNonceAccountInstruction";
           }
-          if (instruction.info.type === "authorizeNonceAccount") {
+          if (instruction.instructionType === "authorizeNonceAccount") {
             return "AuthorizeNonceAccountInstruction";
           }
-          if (instruction.info.type === "upgradeNonceAccount") {
+          if (instruction.instructionType === "upgradeNonceAccount") {
             return "UpgradeNonceAccountInstruction";
           }
-          if (instruction.info.type === "allocate") {
+          if (instruction.instructionType === "allocate") {
             return "AllocateInstruction";
           }
-          if (instruction.info.type === "allocateWithSeed") {
+          if (instruction.instructionType === "allocateWithSeed") {
             return "AllocateWithSeedInstruction";
           }
-          if (instruction.info.type === "assignWithSeed") {
+          if (instruction.instructionType === "assignWithSeed") {
             return "AssignWithSeedInstruction";
           }
-          if (instruction.info.type === "transferWithSeed") {
+          if (instruction.instructionType === "transferWithSeed") {
             return "TransferWithSeedInstruction";
           }
         }
-        if (instruction.program === "vote") {
-          if (instruction.info.type === "initialize") {
+        if (instruction.programName === "vote") {
+          if (instruction.instructionType === "initialize") {
             return "VoteInitializeAccountInstruction";
           }
-          if (instruction.info.type === "authorize") {
+          if (instruction.instructionType === "authorize") {
             return "VoteAuthorizeInstruction";
           }
-          if (instruction.info.type === "authorizeWithSeed") {
+          if (instruction.instructionType === "authorizeWithSeed") {
             return "VoteAuthorizeWithSeedInstruction";
           }
-          if (instruction.info.type === "authorizeCheckedWithSeed") {
+          if (instruction.instructionType === "authorizeCheckedWithSeed") {
             return "VoteAuthorizeCheckedWithSeedInstruction";
           }
-          if (instruction.info.type === "vote") {
+          if (instruction.instructionType === "vote") {
             return "VoteVoteInstruction";
           }
-          if (instruction.info.type === "updatevotestate") {
+          if (instruction.instructionType === "updatevotestate") {
             return "VoteUpdateVoteStateInstruction";
           }
-          if (instruction.info.type === "updatevotestateswitch") {
+          if (instruction.instructionType === "updatevotestateswitch") {
             return "VoteUpdateVoteStateSwitchInstruction";
           }
-          if (instruction.info.type === "compactupdatevotestate") {
+          if (instruction.instructionType === "compactupdatevotestate") {
             return "VoteCompactUpdateVoteStateInstruction";
           }
-          if (instruction.info.type === "compactupdatevotestateswitch") {
+          if (instruction.instructionType === "compactupdatevotestateswitch") {
             return "VoteCompactUpdateVoteStateSwitchInstruction";
           }
-          if (instruction.info.type === "withdraw") {
+          if (instruction.instructionType === "withdraw") {
             return "VoteWithdrawInstruction";
           }
-          if (instruction.info.type === "updateValidatorIdentity") {
+          if (instruction.instructionType === "updateValidatorIdentity") {
             return "VoteUpdateValidatorIdentityInstruction";
           }
-          if (instruction.info.type === "updateCommission") {
+          if (instruction.instructionType === "updateCommission") {
             return "VoteUpdateCommissionInstruction";
           }
-          if (instruction.info.type === "voteSwitch") {
+          if (instruction.instructionType === "voteSwitch") {
             return "VoteVoteSwitchInstruction";
           }
-          if (instruction.info.type === "authorizeChecked") {
+          if (instruction.instructionType === "authorizeChecked") {
             return "VoteAuthorizeCheckedInstruction";
           }
         }
-        return "PartiallyDecodedInstruction";
-      }
-    });
-  return memoisedParsedTransactionInstructionInterface;
-};
-var parsedTransactionInstructionType = (name, parsedInfoFields) => new graphql.GraphQLObjectType({
-  fields: {
-    parsed: object(name + "Parsed", {
-      info: object(name + "ParsedInfo", parsedInfoFields),
-      type: string()
-    }),
-    program: string(),
-    programId: string()
-  },
-  interfaces: [parsedTransactionInstructionInterface()],
-  name
-});
-var memoisedPartiallyDecodedTransactionInstruction;
-var partiallyDecodedTransactionInstruction = () => {
-  if (!memoisedPartiallyDecodedTransactionInstruction)
-    memoisedPartiallyDecodedTransactionInstruction = new graphql.GraphQLObjectType({
-      fields: {
-        accounts: list(string()),
-        data: string(),
-        programId: string()
-      },
-      interfaces: [parsedTransactionInstructionInterface()],
-      name: "PartiallyDecodedInstruction"
-    });
-  return memoisedPartiallyDecodedTransactionInstruction;
-};
-var memoisedParsedInstructionsAddressLookupTable;
-var parsedInstructionsAddressLookupTable = () => {
-  if (!memoisedParsedInstructionsAddressLookupTable)
-    memoisedParsedInstructionsAddressLookupTable = [
-      parsedTransactionInstructionType("CreateLookupTableInstruction", {
-        bumpSeed: number(),
-        lookupTableAccount: string(),
-        lookupTableAuthority: string(),
-        payerAccount: string(),
-        recentSlot: bigint(),
-        systemProgram: string()
-      }),
-      parsedTransactionInstructionType("FreezeLookupTableInstruction", {
-        lookupTableAccount: string(),
-        lookupTableAuthority: string()
-      }),
-      parsedTransactionInstructionType("ExtendLookupTableInstruction", {
-        lookupTableAccount: string(),
-        lookupTableAuthority: string(),
-        newAddresses: list(string()),
-        payerAccount: string(),
-        systemProgram: string()
-      }),
-      parsedTransactionInstructionType("DeactivateLookupTableInstruction", {
-        lookupTableAccount: string(),
-        lookupTableAuthority: string()
-      }),
-      parsedTransactionInstructionType("CloseLookupTableInstruction", {
-        lookupTableAccount: string(),
-        lookupTableAuthority: string(),
-        recipient: string()
-      })
-    ];
-  return memoisedParsedInstructionsAddressLookupTable;
-};
-var memoisedParsedInstructionsBpfLoader;
-var parsedInstructionsBpfLoader = () => {
-  if (!memoisedParsedInstructionsBpfLoader)
-    memoisedParsedInstructionsBpfLoader = [
-      parsedTransactionInstructionType("BpfLoaderWriteInstruction", {
-        account: string(),
-        bytes: string(),
-        offset: number()
-      }),
-      parsedTransactionInstructionType("BpfLoaderFinalizeInstruction", {
-        account: string()
-      })
-    ];
-  return memoisedParsedInstructionsBpfLoader;
-};
-var memoisedParsedInstructionsBpfUpgradeableLoader;
-var parsedInstructionsBpfUpgradeableLoader = () => {
-  if (!memoisedParsedInstructionsBpfUpgradeableLoader)
-    memoisedParsedInstructionsBpfUpgradeableLoader = [
-      parsedTransactionInstructionType("BpfUpgradeableLoaderInitializeBufferInstruction", {
-        account: string()
-      }),
-      parsedTransactionInstructionType("BpfUpgradeableLoaderWriteInstruction", {
-        account: string(),
-        authority: string(),
-        bytes: string(),
-        offset: number()
-      }),
-      parsedTransactionInstructionType("BpfUpgradeableLoaderDeployWithMaxDataLenInstruction", {
-        authority: string(),
-        bufferAccount: string(),
-        clockSysvar: string(),
-        maxDataLen: bigint(),
-        payerAccount: string(),
-        programAccount: string(),
-        programDataAccount: string(),
-        rentSysvar: string()
-      }),
-      parsedTransactionInstructionType("BpfUpgradeableLoaderUpgradeInstruction", {
-        authority: string(),
-        bufferAccount: string(),
-        clockSysvar: string(),
-        programAccount: string(),
-        programDataAccount: string(),
-        rentSysvar: string(),
-        spillAccount: string()
-      }),
-      parsedTransactionInstructionType("BpfUpgradeableLoaderSetAuthorityInstruction", {
-        account: string(),
-        authority: string(),
-        newAuthority: string()
-      }),
-      parsedTransactionInstructionType("BpfUpgradeableLoaderSetAuthorityCheckedInstruction", {
-        account: string(),
-        authority: string(),
-        newAuthority: string()
-      }),
-      parsedTransactionInstructionType("BpfUpgradeableLoaderCloseInstruction", {
-        account: string(),
-        authority: string(),
-        programAccount: string(),
-        recipient: string()
-      }),
-      parsedTransactionInstructionType("BpfUpgradeableLoaderExtendProgramInstruction", {
-        additionalBytes: bigint(),
-        payerAccount: string(),
-        programAccount: string(),
-        programDataAccount: string(),
-        systemProgram: string()
-      })
-    ];
-  return memoisedParsedInstructionsBpfUpgradeableLoader;
-};
-var memoisedParsedInstructionsSplAssociatedToken;
-var parsedInstructionsSplAssociatedToken = () => {
-  if (!memoisedParsedInstructionsSplAssociatedToken)
-    memoisedParsedInstructionsSplAssociatedToken = [
-      parsedTransactionInstructionType("SplAssociatedTokenCreateInstruction", {
-        account: string(),
-        mint: string(),
-        source: string(),
-        systemProgram: string(),
-        tokenProgram: string(),
-        wallet: string()
-      }),
-      parsedTransactionInstructionType("SplAssociatedTokenCreateIdempotentInstruction", {
-        account: string(),
-        mint: string(),
-        source: string(),
-        systemProgram: string(),
-        tokenProgram: string(),
-        wallet: string()
-      }),
-      parsedTransactionInstructionType("SplAssociatedTokenRecoverNestedInstruction", {
-        destination: string(),
-        nestedMint: string(),
-        nestedOwner: string(),
-        nestedSource: string(),
-        ownerMint: string(),
-        tokenProgram: string(),
-        wallet: string()
-      })
-    ];
-  return memoisedParsedInstructionsSplAssociatedToken;
-};
-var memoisedParsedInstructionSplMemo;
-var parsedInstructionSplMemo = () => {
-  if (!memoisedParsedInstructionSplMemo)
-    memoisedParsedInstructionSplMemo = new graphql.GraphQLObjectType({
-      fields: {
-        parsed: string(),
-        program: string(),
-        programId: string()
-      },
-      interfaces: [parsedTransactionInstructionInterface()],
-      name: "SplMemoInstruction"
-    });
-  return memoisedParsedInstructionSplMemo;
-};
-var memoisedParsedInstructionsSplToken;
-var parsedInstructionsSplToken = () => {
-  if (!memoisedParsedInstructionsSplToken)
-    memoisedParsedInstructionsSplToken = [
-      parsedTransactionInstructionType("SplTokenInitializeMintInstruction", {
-        decimals: number(),
-        freezeAuthority: string(),
-        mint: string(),
-        mintAuthority: string(),
-        rentSysvar: string()
-      }),
-      parsedTransactionInstructionType("SplTokenInitializeMint2Instruction", {
-        decimals: number(),
-        freezeAuthority: string(),
-        mint: string(),
-        mintAuthority: string()
-      }),
-      parsedTransactionInstructionType("SplTokenInitializeAccountInstruction", {
-        account: string(),
-        mint: string(),
-        owner: string(),
-        rentSysvar: string()
-      }),
-      parsedTransactionInstructionType("SplTokenInitializeAccount2Instruction", {
-        account: string(),
-        mint: string(),
-        owner: string(),
-        rentSysvar: string()
-      }),
-      parsedTransactionInstructionType("SplTokenInitializeAccount3Instruction", {
-        account: string(),
-        mint: string(),
-        owner: string()
-      }),
-      parsedTransactionInstructionType("SplTokenInitializeMultisigInstruction", {
-        m: number(),
-        multisig: string(),
-        rentSysvar: string(),
-        signers: list(string())
-      }),
-      parsedTransactionInstructionType("SplTokenInitializeMultisig2Instruction", {
-        m: number(),
-        multisig: string(),
-        signers: list(string())
-      }),
-      parsedTransactionInstructionType("SplTokenTransferInstruction", {
-        amount: string(),
-        authority: string(),
-        destination: string(),
-        multisigAuthority: string(),
-        source: string()
-      }),
-      parsedTransactionInstructionType("SplTokenApproveInstruction", {
-        amount: string(),
-        delegate: string(),
-        multisigOwner: string(),
-        owner: string(),
-        source: string()
-      }),
-      parsedTransactionInstructionType("SplTokenRevokeInstruction", {
-        multisigOwner: string(),
-        owner: string(),
-        source: string()
-      }),
-      parsedTransactionInstructionType("SplTokenSetAuthorityInstruction", {
-        authority: string(),
-        authorityType: string(),
-        multisigAuthority: string(),
-        newAuthority: string()
-      }),
-      parsedTransactionInstructionType("SplTokenMintToInstruction", {
-        account: string(),
-        amount: string(),
-        authority: string(),
-        mint: string(),
-        mintAuthority: string(),
-        multisigMintAuthority: string()
-      }),
-      parsedTransactionInstructionType("SplTokenBurnInstruction", {
-        account: string(),
-        amount: string(),
-        authority: string(),
-        mint: string(),
-        multisigAuthority: string()
-      }),
-      parsedTransactionInstructionType("SplTokenCloseAccountInstruction", {
-        account: string(),
-        destination: string(),
-        multisigOwner: string(),
-        owner: string()
-      }),
-      parsedTransactionInstructionType("SplTokenFreezeAccountInstruction", {
-        account: string(),
-        freezeAuthority: string(),
-        mint: string(),
-        multisigFreezeAuthority: string()
-      }),
-      parsedTransactionInstructionType("SplTokenThawAccountInstruction", {
-        account: string(),
-        freezeAuthority: string(),
-        mint: string(),
-        multisigFreezeAuthority: string()
-      }),
-      parsedTransactionInstructionType("SplTokenTransferCheckedInstruction", {
-        authority: string(),
-        destination: string(),
-        mint: string(),
-        multisigAuthority: string(),
-        source: string(),
-        tokenAmount: string()
-      }),
-      parsedTransactionInstructionType("SplTokenApproveCheckedInstruction", {
-        delegate: string(),
-        mint: string(),
-        multisigOwner: string(),
-        owner: string(),
-        source: string(),
-        tokenAmount: string()
-      }),
-      parsedTransactionInstructionType("SplTokenMintToCheckedInstruction", {
-        account: string(),
-        authority: string(),
-        mint: string(),
-        mintAuthority: string(),
-        multisigMintAuthority: string(),
-        tokenAmount: string()
-      }),
-      parsedTransactionInstructionType("SplTokenBurnCheckedInstruction", {
-        account: string(),
-        authority: string(),
-        mint: string(),
-        multisigAuthority: string(),
-        tokenAmount: string()
-      }),
-      parsedTransactionInstructionType("SplTokenSyncNativeInstruction", {
-        account: string()
-      }),
-      parsedTransactionInstructionType("SplTokenGetAccountDataSizeInstruction", {
-        extensionTypes: list(string()),
-        mint: string()
-      }),
-      parsedTransactionInstructionType("SplTokenInitializeImmutableOwnerInstruction", {
-        account: string()
-      }),
-      parsedTransactionInstructionType("SplTokenAmountToUiAmountInstruction", {
-        amount: string(),
-        mint: string()
-      }),
-      parsedTransactionInstructionType("SplTokenUiAmountToAmountInstruction", {
-        mint: string(),
-        uiAmount: string()
-      }),
-      parsedTransactionInstructionType("SplTokenInitializeMintCloseAuthorityInstruction", {
-        mint: string(),
-        newAuthority: string()
-      })
-      // TODO: Extensions!
-      // - TransferFeeExtension
-      // - ConfidentialTransferFeeExtension
-      // - DefaultAccountStateExtension
-      // - Reallocate
-      // - MemoTransferExtension
-      // - CreateNativeMint
-      // - InitializeNonTransferableMint
-      // - InterestBearingMintExtension
-      // - CpiGuardExtension
-      // - InitializePermanentDelegate
-      // - TransferHookExtension
-      // - ConfidentialTransferFeeExtension
-      // - WithdrawExcessLamports
-      // - MetadataPointerExtension
-    ];
-  return memoisedParsedInstructionsSplToken;
-};
-var memoisedLockup;
-var lockup = () => {
-  if (!memoisedLockup)
-    memoisedLockup = new graphql.GraphQLObjectType({
-      fields: {
-        custodian: string(),
-        epoch: bigint(),
-        unixTimestamp: bigint()
-      },
-      name: "Lockup"
-    });
-  return memoisedLockup;
-};
-var memoisedParsedInstructionsStake;
-var parsedInstructionsStake = () => {
-  if (!memoisedParsedInstructionsStake)
-    memoisedParsedInstructionsStake = [
-      parsedTransactionInstructionType("StakeInitializeInstruction", {
-        authorized: object("StakeInitializeInstructionAuthorized", {
-          staker: string(),
-          withdrawer: string()
-        }),
-        lockup: object("StakeInitializeInstructionLockup", {
-          custodian: string(),
-          epoch: bigint(),
-          unixTimestamp: bigint()
-        }),
-        rentSysvar: string(),
-        stakeAccount: string()
-      }),
-      parsedTransactionInstructionType("StakeAuthorizeInstruction", {
-        authority: string(),
-        authorityType: string(),
-        clockSysvar: string(),
-        custodian: string(),
-        newAuthority: string(),
-        stakeAccount: string()
-      }),
-      parsedTransactionInstructionType("StakeDelegateStakeInstruction", {
-        clockSysvar: string(),
-        stakeAccount: string(),
-        stakeAuthority: string(),
-        stakeConfigAccount: string(),
-        stakeHistorySysvar: string(),
-        voteAccount: string()
-      }),
-      parsedTransactionInstructionType("StakeSplitInstruction", {
-        lamports: bigint(),
-        newSplitAccount: string(),
-        stakeAccount: string(),
-        stakeAuthority: string()
-      }),
-      parsedTransactionInstructionType("StakeWithdrawInstruction", {
-        clockSysvar: string(),
-        destination: string(),
-        lamports: bigint(),
-        stakeAccount: string(),
-        withdrawAuthority: string()
-      }),
-      parsedTransactionInstructionType("StakeDeactivateInstruction", {
-        clockSysvar: string(),
-        stakeAccount: string(),
-        stakeAuthority: string()
-      }),
-      parsedTransactionInstructionType("StakeSetLockupInstruction", {
-        custodian: string(),
-        lockup: type(lockup()),
-        stakeAccount: string()
-      }),
-      parsedTransactionInstructionType("StakeMergeInstruction", {
-        clockSysvar: string(),
-        destination: string(),
-        source: string(),
-        stakeAuthority: string(),
-        stakeHistorySysvar: string()
-      }),
-      parsedTransactionInstructionType("StakeAuthorizeWithSeedInstruction", {
-        authorityBase: string(),
-        authorityOwner: string(),
-        authoritySeed: string(),
-        authorityType: string(),
-        clockSysvar: string(),
-        custodian: string(),
-        newAuthorized: string(),
-        stakeAccount: string()
-      }),
-      parsedTransactionInstructionType("StakeInitializeCheckedInstruction", {
-        rentSysvar: string(),
-        stakeAccount: string(),
-        staker: string(),
-        withdrawer: string()
-      }),
-      parsedTransactionInstructionType("StakeAuthorizeCheckedInstruction", {
-        authority: string(),
-        authorityType: string(),
-        clockSysvar: string(),
-        custodian: string(),
-        newAuthority: string(),
-        stakeAccount: string()
-      }),
-      parsedTransactionInstructionType("StakeAuthorizeCheckedWithSeedInstruction", {
-        authorityBase: string(),
-        authorityOwner: string(),
-        authoritySeed: string(),
-        authorityType: string(),
-        clockSysvar: string(),
-        custodian: string(),
-        newAuthorized: string(),
-        stakeAccount: string()
-      }),
-      parsedTransactionInstructionType("StakeSetLockupCheckedInstruction", {
-        custodian: string(),
-        lockup: type(lockup()),
-        stakeAccount: string()
-      }),
-      parsedTransactionInstructionType("StakeDeactivateDelinquentInstruction", {
-        referenceVoteAccount: string(),
-        stakeAccount: string(),
-        voteAccount: string()
-      }),
-      parsedTransactionInstructionType("StakeRedelegateInstruction", {
-        newStakeAccount: string(),
-        stakeAccount: string(),
-        stakeAuthority: string(),
-        stakeConfigAccount: string(),
-        voteAccount: string()
-      })
-    ];
-  return memoisedParsedInstructionsStake;
-};
-var memoisedParsedInstructionsSystem;
-var parsedInstructionsSystem = () => {
-  if (!memoisedParsedInstructionsSystem)
-    memoisedParsedInstructionsSystem = [
-      parsedTransactionInstructionType("CreateAccountInstruction", {
-        lamports: bigint(),
-        newAccount: string(),
-        owner: string(),
-        source: string(),
-        space: bigint()
-      }),
-      parsedTransactionInstructionType("AssignInstruction", {
-        owner: string()
-      }),
-      parsedTransactionInstructionType("TransferInstruction", {
-        amount: string(),
-        lamports: number(),
-        source: string()
-      }),
-      parsedTransactionInstructionType("CreateAccountWithSeedInstruction", {
-        base: string(),
-        lamports: bigint(),
-        owner: string(),
-        seed: string(),
-        space: bigint()
-      }),
-      parsedTransactionInstructionType("AdvanceNonceAccountInstruction", {
-        nonceAccount: string(),
-        nonceAuthority: string(),
-        recentBlockhashesSysvar: string()
-      }),
-      parsedTransactionInstructionType("WithdrawNonceAccountInstruction", {
-        destination: string(),
-        lamports: bigint(),
-        nonceAccount: string(),
-        nonceAuthority: string(),
-        recentBlockhashesSysvar: string(),
-        rentSysvar: string()
-      }),
-      parsedTransactionInstructionType("InitializeNonceAccountInstruction", {
-        nonceAccount: string(),
-        nonceAuthority: string(),
-        recentBlockhashesSysvar: string(),
-        rentSysvar: string()
-      }),
-      parsedTransactionInstructionType("AuthorizeNonceAccountInstruction", {
-        newAuthorized: string(),
-        nonceAccount: string(),
-        nonceAuthority: string()
-      }),
-      parsedTransactionInstructionType("UpgradeNonceAccountInstruction", {
-        nonceAccount: string()
-      }),
-      parsedTransactionInstructionType("AllocateInstruction", {
-        account: string(),
-        space: bigint()
-      }),
-      parsedTransactionInstructionType("AllocateWithSeedInstruction", {
-        account: string(),
-        base: string(),
-        owner: string(),
-        seed: string(),
-        space: bigint()
-      }),
-      parsedTransactionInstructionType("AssignWithSeedInstruction", {
-        account: string(),
-        base: string(),
-        owner: string(),
-        seed: string()
-      }),
-      parsedTransactionInstructionType("TransferWithSeedInstruction", {
-        destination: string(),
-        lamports: bigint(),
-        source: string(),
-        sourceBase: string(),
-        sourceOwner: string(),
-        sourceSeed: string()
-      })
-    ];
-  return memoisedParsedInstructionsSystem;
-};
-var memoisedVote;
-var vote = () => {
-  if (!memoisedVote)
-    memoisedVote = new graphql.GraphQLObjectType({
-      fields: {
-        hash: string(),
-        slots: list(bigint()),
-        timestamp: bigint()
-      },
-      name: "Vote"
-    });
-  return memoisedVote;
-};
-var memoisedVoteStateUpdate;
-var voteStateUpdate = () => {
-  if (!memoisedVoteStateUpdate)
-    memoisedVoteStateUpdate = new graphql.GraphQLObjectType({
-      fields: {
-        hash: string(),
-        lockouts: list(
-          object("VoteStateUpdateLockout", {
-            confirmationCount: number(),
-            slot: bigint()
-          })
-        ),
-        root: bigint(),
-        timestamp: bigint()
-      },
-      name: "VoteStateUpdate"
-    });
-  return memoisedVoteStateUpdate;
-};
-var memoisedParsedInstructionsVote;
-var parsedInstructionsVote = () => {
-  if (!memoisedParsedInstructionsVote)
-    memoisedParsedInstructionsVote = [
-      parsedTransactionInstructionType("VoteInitializeAccountInstruction", {
-        authorizedVoter: string(),
-        authorizedWithdrawer: string(),
-        clockSysvar: string(),
-        commission: number(),
-        node: string(),
-        rentSysvar: string(),
-        voteAccount: string()
-      }),
-      parsedTransactionInstructionType("VoteAuthorizeInstruction", {
-        authority: string(),
-        authorityType: string(),
-        clockSysvar: string(),
-        newAuthority: string(),
-        voteAccount: string()
-      }),
-      parsedTransactionInstructionType("VoteAuthorizeWithSeedInstruction", {
-        authorityBaseKey: string(),
-        authorityOwner: string(),
-        authoritySeed: string(),
-        authorityType: string(),
-        clockSysvar: string(),
-        newAuthority: string(),
-        voteAccount: string()
-      }),
-      parsedTransactionInstructionType("VoteAuthorizeCheckedWithSeedInstruction", {
-        authorityBaseKey: string(),
-        authorityOwner: string(),
-        authoritySeed: string(),
-        authorityType: string(),
-        clockSysvar: string(),
-        newAuthority: string(),
-        voteAccount: string()
-      }),
-      parsedTransactionInstructionType("VoteVoteInstruction", {
-        clockSysvar: string(),
-        slotHashedSysvar: string(),
-        vote: type(vote()),
-        voteAccount: string(),
-        voteAuthority: string()
-      }),
-      parsedTransactionInstructionType("VoteUpdateVoteStateInstruction", {
-        hash: string(),
-        voteAccount: string(),
-        voteAuthority: string(),
-        voteStateUpdate: type(voteStateUpdate())
-      }),
-      parsedTransactionInstructionType("VoteUpdateVoteStateSwitchInstruction", {
-        hash: string(),
-        voteAccount: string(),
-        voteAuthority: string(),
-        voteStateUpdate: type(voteStateUpdate())
-      }),
-      parsedTransactionInstructionType("VoteCompactUpdateVoteStateInstruction", {
-        hash: string(),
-        voteAccount: string(),
-        voteAuthority: string(),
-        voteStateUpdate: type(voteStateUpdate())
-      }),
-      parsedTransactionInstructionType("VoteCompactUpdateVoteStateSwitchInstruction", {
-        hash: string(),
-        voteAccount: string(),
-        voteAuthority: string(),
-        voteStateUpdate: type(voteStateUpdate())
-      }),
-      parsedTransactionInstructionType("VoteWithdrawInstruction", {
-        destination: string(),
-        lamports: bigint(),
-        voteAccount: string(),
-        withdrawAuthority: string()
-      }),
-      parsedTransactionInstructionType("VoteUpdateValidatorIdentityInstruction", {
-        newValidatorIdentity: string(),
-        voteAccount: string(),
-        withdrawAuthority: string()
-      }),
-      parsedTransactionInstructionType("VoteUpdateCommissionInstruction", {
-        commission: string(),
-        voteAccount: string(),
-        withdrawAuthority: string()
-      }),
-      parsedTransactionInstructionType("VoteVoteSwitchInstruction", {
-        clockSysvar: string(),
-        hash: string(),
-        slotHashesSysvar: string(),
-        vote: type(vote()),
-        voteAccount: string(),
-        voteAuthority: string()
-      }),
-      parsedTransactionInstructionType("VoteAuthorizeCheckedInstruction", {
-        authority: string(),
-        authorityType: string(),
-        clockSysvar: string(),
-        newAuthority: string(),
-        voteAccount: string()
-      })
-    ];
-  return memoisedParsedInstructionsVote;
-};
-var memoisedTransactionMetaInterfaceFields;
-var transactionMetaInterfaceFields = () => {
-  if (!memoisedTransactionMetaInterfaceFields)
-    memoisedTransactionMetaInterfaceFields = {
-      computeUnitsConsumed: bigint(),
-      err: string(),
-      fee: bigint(),
-      format: string(),
-      loadedAddresses: type(transactionMetaLoadedAddresses()),
-      logMessages: list(string()),
-      postBalances: list(bigint()),
-      postTokenBalances: list(type(tokenBalance())),
-      preBalances: list(bigint()),
-      preTokenBalances: list(type(tokenBalance())),
-      returnData: type(returnData()),
-      rewards: list(type(reward())),
-      status: type(transactionStatus())
-    };
-  return memoisedTransactionMetaInterfaceFields;
-};
-var memoisedTransactionMetaInterface;
-var transactionMetaInterface = () => {
-  if (!memoisedTransactionMetaInterface)
-    memoisedTransactionMetaInterface = new graphql.GraphQLInterfaceType({
-      fields: {
-        ...transactionMetaInterfaceFields()
-      },
-      name: "TransactionMeta",
-      resolveType(meta) {
-        if (meta.format === "parsed") {
-          return "TransactionMetaParsed";
-        }
-        return "TransactionMetaUnparsed";
-      }
-    });
-  return memoisedTransactionMetaInterface;
-};
-var transactionMetaType = (name, description, innerInstructions) => new graphql.GraphQLObjectType({
-  description,
-  fields: {
-    ...transactionMetaInterfaceFields(),
-    innerInstructions
-  },
-  interfaces: [transactionMetaInterface()],
-  name
-});
-var memoisedTransactionMetaUnparsed;
-var transactionMetaUnparsed = () => {
-  if (!memoisedTransactionMetaUnparsed)
-    memoisedTransactionMetaUnparsed = transactionMetaType(
-      "TransactionMetaUnparsed",
-      "Non-parsed transaction meta",
-      list(
-        object("TransactionMetaInnerInstructionsUnparsed", {
-          index: number(),
-          instructions: list(
-            object("TransactionMetaInnerInstructionsUnparsedInstruction", {
-              index: number(),
-              instructions: list(type(transactionInstruction()))
-            })
-          )
-        })
-      )
-    );
-  return memoisedTransactionMetaUnparsed;
-};
-var memoisedTransactionMetaParsed;
-var transactionMetaParsed = () => {
-  if (!memoisedTransactionMetaParsed)
-    memoisedTransactionMetaParsed = transactionMetaType(
-      "TransactionMetaParsed",
-      "Parsed transaction meta",
-      list(
-        object("TransactionMetaInnerInstructionsParsed", {
-          index: number(),
-          instructions: list(type(parsedTransactionInstructionInterface()))
-        })
-      )
-    );
-  return memoisedTransactionMetaParsed;
-};
-var memoisedTransactionMessageInterfaceFields;
-var transactionMessageInterfaceFields = () => {
-  if (!memoisedTransactionMessageInterfaceFields)
-    memoisedTransactionMessageInterfaceFields = {
-      addressTableLookups: list(type(addressTableLookup())),
-      format: string(),
-      header: object("TransactionJsonTransactionHeader", {
-        numReadonlySignedAccounts: number(),
-        numReadonlyUnsignedAccounts: number(),
-        numRequiredSignatures: number()
-      }),
-      recentBlockhash: string()
-    };
-  return memoisedTransactionMessageInterfaceFields;
-};
-var memoisedTransactionMessageInterface;
-var transactionMessageInterface = () => {
-  if (!memoisedTransactionMessageInterface)
-    memoisedTransactionMessageInterface = new graphql.GraphQLInterfaceType({
-      fields: {
-        ...transactionMessageInterfaceFields()
-      },
-      name: "TransactionMessage",
-      resolveType(message) {
-        if (message.format === "parsed") {
-          return "TransactionMessageParsed";
-        }
-        return "TransactionMessageUnparsed";
       }
-    });
-  return memoisedTransactionMessageInterface;
-};
-var transactionMessageType = (name, description, accountKeys, instructions) => new graphql.GraphQLObjectType({
-  description,
-  fields: {
-    ...transactionMessageInterfaceFields(),
-    accountKeys,
-    instructions
-  },
-  interfaces: [transactionMessageInterface()],
-  name
-});
-var memoisedTransactionMessageUnparsed;
-var transactionMessageUnparsed = () => {
-  if (!memoisedTransactionMessageUnparsed)
-    memoisedTransactionMessageUnparsed = transactionMessageType(
-      "TransactionMessageUnparsed",
-      "Non-parsed transaction message",
-      list(string()),
-      list(type(transactionInstruction()))
-    );
-  return memoisedTransactionMessageUnparsed;
-};
-var memoisedTransactionMessageParsed;
-var transactionMessageParsed = () => {
-  if (!memoisedTransactionMessageParsed)
-    memoisedTransactionMessageParsed = transactionMessageType(
-      "TransactionMessageParsed",
-      "Parsed transaction message",
-      list(
-        object("transactionMessageParsedAccountKey", {
-          pubkey: string(),
-          signer: boolean(),
-          source: string(),
-          writable: boolean()
-        })
-      ),
-      list(type(parsedTransactionInstructionInterface()))
-    );
-  return memoisedTransactionMessageParsed;
-};
-var memoisedTransactionTransaction;
-var transactionTransaction = () => {
-  if (!memoisedTransactionTransaction)
-    memoisedTransactionTransaction = new graphql.GraphQLObjectType({
-      fields: {
-        message: type(transactionMessageInterface()),
-        signatures: list(string())
-      },
-      name: "TransactionTransaction"
-    });
-  return memoisedTransactionTransaction;
-};
-var memoisedTransactionInterfaceFields;
-var transactionInterfaceFields = () => {
-  if (!memoisedTransactionInterfaceFields)
-    memoisedTransactionInterfaceFields = {
-      blockTime: bigint(),
-      encoding: string(),
-      meta: type(transactionMetaInterface()),
-      slot: bigint()
-    };
-  return memoisedTransactionInterfaceFields;
+      return "GenericInstruction";
+    }
+  },
+  CreateLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority"),
+    payerAccount: resolveAccount("payerAccount"),
+    systemProgram: resolveAccount("systemProgram")
+  },
+  ExtendLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority"),
+    payerAccount: resolveAccount("payerAccount"),
+    systemProgram: resolveAccount("systemProgram")
+  },
+  FreezeLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority")
+  },
+  DeactivateLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority")
+  },
+  CloseLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority"),
+    recipient: resolveAccount("recipient")
+  },
+  BpfLoaderWriteInstruction: {
+    account: resolveAccount("account")
+  },
+  BpfLoaderFinalizeInstruction: {
+    account: resolveAccount("account")
+  },
+  BpfUpgradeableLoaderInitializeBufferInstruction: {
+    account: resolveAccount("account")
+  },
+  BpfUpgradeableLoaderWriteInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority")
+  },
+  BpfUpgradeableLoaderDeployWithMaxDataLenInstruction: {
+    authority: resolveAccount("authority"),
+    bufferAccount: resolveAccount("bufferAccount"),
+    payerAccount: resolveAccount("payerAccount"),
+    programAccount: resolveAccount("programAccount"),
+    programDataAccount: resolveAccount("programDataAccount")
+  },
+  BpfUpgradeableLoaderUpgradeInstruction: {
+    authority: resolveAccount("authority"),
+    bufferAccount: resolveAccount("bufferAccount"),
+    programAccount: resolveAccount("programAccount"),
+    programDataAccount: resolveAccount("programDataAccount")
+  },
+  BpfUpgradeableLoaderSetAuthorityInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  BpfUpgradeableLoaderSetAuthorityCheckedInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  BpfUpgradeableLoaderCloseInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    programAccount: resolveAccount("programAccount"),
+    recipient: resolveAccount("recipient")
+  },
+  BpfUpgradeableLoaderExtendProgramInstruction: {
+    payerAccount: resolveAccount("payerAccount"),
+    programAccount: resolveAccount("programAccount"),
+    programDataAccount: resolveAccount("programDataAccount"),
+    systemProgram: resolveAccount("systemProgram")
+  },
+  SplAssociatedTokenCreateInstruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    source: resolveAccount("source"),
+    systemProgram: resolveAccount("systemProgram"),
+    tokenProgram: resolveAccount("tokenProgram"),
+    wallet: resolveAccount("wallet")
+  },
+  SplAssociatedTokenCreateIdempotentInstruction: {
+    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")
+  },
+  SplTokenInitializeMintInstruction: {
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority")
+  },
+  SplTokenInitializeMint2Instruction: {
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority")
+  },
+  SplTokenInitializeAccountInstruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner")
+  },
+  SplTokenInitializeAccount2Instruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner")
+  },
+  SplTokenInitializeAccount3Instruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner")
+  },
+  SplTokenInitializeMultisigInstruction: {
+    multisig: resolveAccount("multisig")
+  },
+  SplTokenInitializeMultisig2Instruction: {
+    multisig: resolveAccount("multisig")
+  },
+  SplTokenTransferInstruction: {
+    authority: resolveAccount("authority"),
+    destination: resolveAccount("destination"),
+    multisigAuthority: resolveAccount("multisigAuthority"),
+    source: resolveAccount("source")
+  },
+  SplTokenApproveInstruction: {
+    delegate: resolveAccount("delegate"),
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
+  },
+  SplTokenRevokeInstruction: {
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
+  },
+  SplTokenSetAuthorityInstruction: {
+    authority: resolveAccount("authority"),
+    multisigAuthority: resolveAccount("multisigAuthority"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  SplTokenMintToInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    multisigMintAuthority: resolveAccount("multisigMintAuthority")
+  },
+  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")
+  },
+  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")
+  },
+  SplTokenApproveCheckedInstruction: {
+    delegate: resolveAccount("delegate"),
+    mint: resolveAccount("mint"),
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
+  },
+  SplTokenMintToCheckedInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    multisigMintAuthority: resolveAccount("multisigMintAuthority")
+  },
+  SplTokenBurnCheckedInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    multisigAuthority: resolveAccount("multisigAuthority")
+  },
+  SplTokenSyncNativeInstruction: {
+    account: resolveAccount("account")
+  },
+  SplTokenGetAccountDataSizeInstruction: {
+    mint: resolveAccount("mint")
+  },
+  SplTokenAmountToUiAmountInstruction: {
+    mint: resolveAccount("mint")
+  },
+  SplTokenUiAmountToAmountInstruction: {
+    mint: resolveAccount("mint")
+  },
+  SplTokenInitializeMintCloseAuthorityInstruction: {
+    mint: resolveAccount("mint"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  Lockup: {
+    custodian: resolveAccount("custodian")
+  },
+  StakeInitializeInstructionDataAuthorized: {
+    staker: resolveAccount("staker"),
+    withdrawer: resolveAccount("withdrawer")
+  },
+  StakeInitializeInstruction: {
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeAuthorizeInstruction: {
+    authority: resolveAccount("authority"),
+    custodian: resolveAccount("custodian"),
+    newAuthority: resolveAccount("newAuthority"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeDelegateStakeInstruction: {
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority"),
+    stakeConfigAccount: resolveAccount("stakeConfigAccount"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  StakeSplitInstruction: {
+    newSplitAccount: resolveAccount("newSplitAccount"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority")
+  },
+  StakeWithdrawInstruction: {
+    destination: resolveAccount("destination"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
+  },
+  StakeDeactivateInstruction: {
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority")
+  },
+  StakeSetLockupInstruction: {
+    custodian: resolveAccount("custodian"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeMergeInstruction: {
+    destination: resolveAccount("destination"),
+    source: resolveAccount("source"),
+    stakeAuthority: resolveAccount("stakeAuthority")
+  },
+  StakeAuthorizeWithSeedInstruction: {
+    authorityBase: resolveAccount("authorityBase"),
+    authorityOwner: resolveAccount("authorityOwner"),
+    custodian: resolveAccount("custodian"),
+    newAuthorized: resolveAccount("newAuthorized"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeInitializeCheckedInstructionDataAuthorized: {
+    staker: resolveAccount("staker"),
+    withdrawer: resolveAccount("withdrawer")
+  },
+  StakeAuthorizeCheckedInstruction: {
+    authority: resolveAccount("authority"),
+    custodian: resolveAccount("custodian"),
+    newAuthority: resolveAccount("newAuthority"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeAuthorizeCheckedWithSeedInstruction: {
+    authorityBase: resolveAccount("authorityBase"),
+    authorityOwner: resolveAccount("authorityOwner"),
+    custodian: resolveAccount("custodian"),
+    newAuthorized: resolveAccount("newAuthorized"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeSetLockupCheckedInstruction: {
+    custodian: resolveAccount("custodian"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeDeactivateDelinquentInstruction: {
+    referenceVoteAccount: resolveAccount("referenceVoteAccount"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  StakeRedelegateInstruction: {
+    newStakeAccount: resolveAccount("newStakeAccount"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority"),
+    stakeConfigAccount: resolveAccount("stakeConfigAccount"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  CreateAccountInstruction: {
+    newAccount: resolveAccount("newAccount"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
+  },
+  AssignInstruction: {
+    account: resolveAccount("account"),
+    owner: resolveAccount("owner")
+  },
+  TransferInstruction: {
+    destination: resolveAccount("destination"),
+    source: resolveAccount("source")
+  },
+  CreateAccountWithSeedInstruction: {
+    base: resolveAccount("base"),
+    owner: resolveAccount("owner"),
+    seed: resolveAccount("seed")
+  },
+  AdvanceNonceAccountInstruction: {
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  },
+  WithdrawNonceAccountInstruction: {
+    destination: resolveAccount("destination"),
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  },
+  InitializeNonceAccountInstruction: {
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  },
+  AuthorizeNonceAccountInstruction: {
+    newAuthorized: resolveAccount("newAuthorized"),
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  },
+  UpgradeNonceAccountInstruction: {
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  },
+  AllocateInstruction: {
+    account: resolveAccount("account")
+  },
+  AllocateWithSeedInstruction: {
+    account: resolveAccount("account"),
+    owner: resolveAccount("owner")
+  },
+  AssignWithSeedInstruction: {
+    account: resolveAccount("account"),
+    owner: resolveAccount("owner")
+  },
+  TransferWithSeedInstruction: {
+    destination: resolveAccount("destination"),
+    source: resolveAccount("source"),
+    sourceOwner: resolveAccount("sourceOwner")
+  },
+  VoteInitializeAccountInstruction: {
+    authorizedVoter: resolveAccount("authorizedVoter"),
+    authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
+    node: resolveAccount("node"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  VoteAuthorizeInstruction: {
+    authority: resolveAccount("authority"),
+    newAuthority: resolveAccount("newAuthority"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  VoteAuthorizeWithSeedInstruction: {
+    authorityOwner: resolveAccount("authorityOwner"),
+    newAuthority: resolveAccount("newAuthority"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  VoteAuthorizeCheckedWithSeedInstruction: {
+    authorityOwner: resolveAccount("authorityOwner"),
+    newAuthority: resolveAccount("newAuthority"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  VoteVoteInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
+  },
+  VoteUpdateVoteStateInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
+  },
+  VoteUpdateVoteStateSwitchInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
+  },
+  VoteCompactUpdateVoteStateInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
+  },
+  VoteCompactUpdateVoteStateSwitchInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
+  },
+  VoteWithdrawInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
+  },
+  VoteUpdateValidatorIdentityInstruction: {
+    newValidatorIdentity: resolveAccount("newValidatorIdentity"),
+    voteAccount: resolveAccount("voteAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
+  },
+  VoteUpdateCommissionInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
+  },
+  VoteVoteSwitchInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
+  },
+  VoteAuthorizeCheckedInstruction: {
+    authority: resolveAccount("authority"),
+    newAuthority: resolveAccount("newAuthority"),
+    voteAccount: resolveAccount("voteAccount")
+  }
 };
-var memoisedTransactionInterface;
-var transactionInterface = () => {
-  if (!memoisedTransactionInterface)
-    memoisedTransactionInterface = new graphql.GraphQLInterfaceType({
-      fields: {
-        ...transactionInterfaceFields()
-      },
-      name: "Transaction",
-      resolveType(transaction) {
-        if (transaction.encoding === "base58") {
+
+// 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
+    }
+
+    # Transaction interface
+    interface Transaction {
+        blockTime: String
+        meta: TransactionMeta
+        slot: BigInt
+        version: String
+    }
+
+    # A transaction with base58 encoded data
+    type TransactionBase58 implements Transaction {
+        blockTime: String
+        data: Base58EncodedBytes
+        meta: TransactionMeta
+        slot: BigInt
+        version: String
+    }
+
+    # A transaction with base64 encoded data
+    type TransactionBase64 implements Transaction {
+        blockTime: String
+        data: Base64EncodedBytes
+        meta: TransactionMeta
+        slot: BigInt
+        version: String
+    }
+
+    # A transaction with JSON encoded data
+    type TransactionDataParsed {
+        message: TransactionMessage
+        signatures: [String]
+    }
+    type TransactionParsed implements Transaction {
+        blockTime: String
+        data: TransactionDataParsed
+        meta: TransactionMeta
+        slot: BigInt
+        version: String
+    }
+`
+);
+var transactionResolvers = {
+  Transaction: {
+    __resolveType(transaction) {
+      switch (transaction.encoding) {
+        case "base58":
           return "TransactionBase58";
-        }
-        if (transaction.encoding === "base64") {
+        case "base64":
           return "TransactionBase64";
-        }
-        if (transaction.encoding === "json") {
-          return "TransactionJson";
-        }
-        return "TransactionJsonParsed";
+        default:
+          return "TransactionParsed";
       }
-    });
-  return memoisedTransactionInterface;
-};
-var transactionType = (name, description, transaction) => new graphql.GraphQLObjectType({
-  description,
-  fields: {
-    ...transactionInterfaceFields(),
-    transaction
-  },
-  interfaces: [transactionInterface()],
-  name
-});
-var memoisedTransactionBase58;
-var transactionBase58 = () => {
-  if (!memoisedTransactionBase58)
-    memoisedTransactionBase58 = transactionType(
-      "TransactionBase58",
-      "A Solana transaction as base58 encoded data",
-      string()
-    );
-  return memoisedTransactionBase58;
-};
-var memoisedTransactionBase64;
-var transactionBase64 = () => {
-  if (!memoisedTransactionBase64)
-    memoisedTransactionBase64 = transactionType(
-      "TransactionBase64",
-      "A Solana transaction as base64 encoded data",
-      string()
-    );
-  return memoisedTransactionBase64;
-};
-var memoisedTransactionJson;
-var transactionJson = () => {
-  if (!memoisedTransactionJson)
-    memoisedTransactionJson = transactionType(
-      "TransactionJson",
-      "A Solana transaction as a JSON object",
-      type(transactionTransaction())
-    );
-  return memoisedTransactionJson;
-};
-var memoisedTransactionJsonParsed;
-var transactionJsonParsed = () => {
-  if (!memoisedTransactionJsonParsed)
-    memoisedTransactionJsonParsed = transactionType(
-      "TransactionJsonParsed",
-      "A Solana transaction as a parsed JSON object",
-      type(transactionTransaction())
-    );
-  return memoisedTransactionJsonParsed;
-};
-var memoisedTransactionTypes;
-var transactionTypes = () => {
-  if (!memoisedTransactionTypes)
-    memoisedTransactionTypes = [
-      partiallyDecodedTransactionInstruction(),
-      ...parsedInstructionsAddressLookupTable(),
-      ...parsedInstructionsBpfLoader(),
-      ...parsedInstructionsBpfUpgradeableLoader(),
-      ...parsedInstructionsStake(),
-      ...parsedInstructionsSplAssociatedToken(),
-      parsedInstructionSplMemo(),
-      ...parsedInstructionsSplToken(),
-      ...parsedInstructionsSystem(),
-      ...parsedInstructionsVote(),
-      transactionMetaUnparsed(),
-      transactionMetaParsed(),
-      transactionMessageUnparsed(),
-      transactionMessageParsed(),
-      transactionBase58(),
-      transactionBase64(),
-      transactionJson(),
-      transactionJsonParsed()
-    ];
-  return memoisedTransactionTypes;
-};
-
-// src/schema/transaction/query.ts
-var transactionQuery = () => ({
-  transaction: {
-    args: {
-      commitment: type(commitmentInputType()),
-      encoding: type(transactionEncodingInputType()),
-      maxSupportedTransactionVersion: type(maxSupportedTransactionVersionInputType()),
-      signature: nonNull(string())
-    },
-    resolve: (_parent, args, context) => context.resolveTransaction(args),
-    type: transactionInterface()
+    }
   }
-});
-
-// src/schema/block/types.ts
-var memoisedTransactionForAccounts;
-var transactionForAccounts = () => {
-  if (!memoisedTransactionForAccounts)
-    memoisedTransactionForAccounts = new graphql.GraphQLObjectType({
-      fields: {
-        meta: object("TransactionMetaForAccounts", {
-          computeUnitsUsed: bigint(),
-          err: string(),
-          fee: bigint(),
-          format: string(),
-          loadedAddresses: type(transactionMetaLoadedAddresses()),
-          logMessages: list(string()),
-          postBalances: list(bigint()),
-          postTokenBalances: list(type(tokenBalance())),
-          preBalances: list(bigint()),
-          preTokenBalances: list(type(tokenBalance())),
-          returnData: type(returnData()),
-          rewards: list(type(reward())),
-          status: type(transactionStatus())
-        }),
-        transaction: type(transactionInterface()),
-        // TODO
-        version: string()
-      },
-      name: "TransactionForAccounts"
-    });
-  return memoisedTransactionForAccounts;
-};
-var memoisedBlockInterfaceFields;
-var blockInterfaceFields = () => {
-  if (!memoisedBlockInterfaceFields)
-    memoisedBlockInterfaceFields = {
-      blockHeight: bigint(),
-      blockTime: bigint(),
-      blockhash: string(),
-      parentSlot: bigint(),
-      previousBlockhash: string(),
-      rewards: list(type(reward()))
-    };
-  return memoisedBlockInterfaceFields;
-};
-var memoisedBlockInterface;
-var blockInterface = () => {
-  if (!memoisedBlockInterface)
-    memoisedBlockInterface = new graphql.GraphQLInterfaceType({
-      fields: {
-        ...blockInterfaceFields()
-      },
-      name: "Block",
-      resolveType(block) {
-        if (block.transactionDetails === "signatures") {
-          return "BlockWithSignatures";
-        }
-        if (block.transactionDetails === "accounts") {
-          return "BlockWithAccounts";
-        }
-        if (block.transactionDetails === "none") {
-          return "BlockWithNoTransactions";
-        }
-        return "BlockWithTransactions";
-      }
-    });
-  return memoisedBlockInterface;
-};
-var memoisedBlockWithNoTransactions;
-var blockWithNoTransactions = () => {
-  if (!memoisedBlockWithNoTransactions)
-    memoisedBlockWithNoTransactions = new graphql.GraphQLObjectType({
-      fields: {
-        ...blockInterfaceFields()
-      },
-      interfaces: [blockInterface()],
-      name: "BlockWithNoTransactions"
-    });
-  return memoisedBlockWithNoTransactions;
-};
-var memoisedBlockWithSignatures;
-var blockWithSignatures = () => {
-  if (!memoisedBlockWithSignatures)
-    memoisedBlockWithSignatures = new graphql.GraphQLObjectType({
-      fields: {
-        ...blockInterfaceFields(),
-        signatures: list(string())
-      },
-      interfaces: [blockInterface()],
-      name: "BlockWithSignatures"
-    });
-  return memoisedBlockWithSignatures;
-};
-var memoisedBlockWithAccounts;
-var blockWithAccounts = () => {
-  if (!memoisedBlockWithAccounts)
-    memoisedBlockWithAccounts = new graphql.GraphQLObjectType({
-      fields: {
-        ...blockInterfaceFields(),
-        transactions: list(type(transactionForAccounts()))
-      },
-      interfaces: [blockInterface()],
-      name: "BlockWithAccounts"
-    });
-  return memoisedBlockWithAccounts;
-};
-var memoisedBlockWithTransactions;
-var blockWithTransactions = () => {
-  if (!memoisedBlockWithTransactions)
-    memoisedBlockWithTransactions = new graphql.GraphQLObjectType({
-      fields: {
-        ...blockInterfaceFields(),
-        transactions: list(type(transactionInterface()))
-      },
-      interfaces: [blockInterface()],
-      name: "BlockWithTransactions"
-    });
-  return memoisedBlockWithTransactions;
-};
-var memoisedBlockTypes;
-var blockTypes = () => {
-  if (!memoisedBlockTypes)
-    memoisedBlockTypes = [
-      blockWithNoTransactions(),
-      blockWithSignatures(),
-      blockWithAccounts(),
-      blockWithTransactions()
-    ];
-  return memoisedBlockTypes;
 };
 
-// src/schema/block/query.ts
-var blockQuery = () => ({
-  block: {
-    args: {
-      commitment: type(commitmentInputType()),
-      encoding: type(transactionEncodingInputType()),
-      maxSupportedTransactionVersion: string(),
-      rewards: boolean(),
-      slot: nonNull(bigint()),
-      transactionDetails: type(blockTransactionDetailsInputType())
+// src/schema/index.ts
+var schemaTypeDefs = (
+  /* GraphQL */
+  `
+    type Query {
+        account(
+            address: String!
+            commitment: Commitment
+            dataSlice: DataSlice
+            encoding: AccountEncoding
+            minContextSlot: BigInt
+        ): Account
+        block(
+            slot: BigInt!
+            commitment: Commitment
+            encoding: TransactionEncoding
+            transactionDetails: BlockTransactionDetails
+        ): Block
+        programAccounts(
+            programAddress: String!
+            commitment: Commitment
+            dataSlice: DataSlice
+            encoding: AccountEncoding
+            filters: [ProgramAccountsFilter]
+            minContextSlot: BigInt
+        ): [Account]
+        transaction(
+            signature: String!
+            commitment: Commitment
+            encoding: TransactionEncoding
+        ): Transaction
+    }
+
+    schema {
+        query: Query
+    }
+`
+);
+var schemaResolvers = {
+  Query: {
+    account(_, args, context, info) {
+      return context.loaders.account.load(args, info);
     },
-    resolve: (_parent, args, context) => context.resolveBlock(args),
-    type: blockInterface()
-  }
-});
-var programAccount = () => new graphql.GraphQLObjectType({
-  fields: {
-    account: type(accountInterface()),
-    pubkey: string()
-  },
-  name: "ProgramAccount"
-});
-
-// src/schema/program-accounts/query.ts
-var programAccountsQuery = () => ({
-  programAccounts: {
-    args: {
-      commitment: type(commitmentInputType()),
-      dataSlice: type(dataSliceInputType()),
-      encoding: type(accountEncodingInputType()),
-      filters: list(type(programAccountFilterInputType())),
-      minContextSlot: bigint(),
-      programAddress: nonNull(string()),
-      withContext: string()
+    block(_, args, context, info) {
+      return context.loaders.block.load(args, info);
+    },
+    programAccounts(_, args, context, info) {
+      return context.loaders.programAccounts.load(args, info);
     },
-    resolve: (_parent, args, context) => context.resolveProgramAccounts(args),
-    type: new graphql.GraphQLList(programAccount())
+    transaction(_, args, context, info) {
+      return context.loaders.transaction.load(args, info);
+    }
   }
-});
+};
+function createSolanaGraphQLSchema() {
+  return schema.makeExecutableSchema({
+    resolvers: {
+      ...accountResolvers,
+      ...blockResolvers,
+      ...commonResolvers,
+      ...inputResolvers,
+      ...instructionResolvers,
+      ...scalarResolvers,
+      ...schemaResolvers,
+      ...transactionResolvers
+    },
+    typeDefs: [
+      accountTypeDefs,
+      blockTypeDefs,
+      commonTypeDefs,
+      inputTypeDefs,
+      instructionTypeDefs,
+      scalarTypeDefs,
+      schemaTypeDefs,
+      transactionTypeDefs
+    ]
+  });
+}
 
 // src/rpc.ts
 function createRpcGraphQL(rpc) {
   const context = createSolanaGraphQLContext(rpc);
-  const schema = new graphql.GraphQLSchema({
-    query: new graphql.GraphQLObjectType({
-      fields: {
-        ...accountQuery(),
-        ...blockQuery(),
-        ...programAccountsQuery(),
-        ...transactionQuery()
-      },
-      name: "RootQuery"
-    }),
-    types: [...accountTypes(), ...blockTypes(), ...transactionTypes()]
-  });
+  const schema = createSolanaGraphQLSchema();
   return {
     context,
     async query(source, variableValues) {
-      const result = await graphql.graphql({
+      return graphql.graphql({
         contextValue: this.context,
         schema: this.schema,
         source,
         variableValues
       });
-      this.context.cache.flush();
-      return result;
     },
     schema
   };