@solana/rpc-graphql 2.0.0-experimental.ef2569b → 2.0.0-experimental.f025b33

package/dist/index.browser.js

@@ -1,11 +1,170 @@
+import { makeExecutableSchema } from '@graphql-tools/schema';
 import { graphql, Kind } from 'graphql';
 import DataLoader from 'dataloader';
-import fastStableStringify from 'fast-stable-stringify';
-import { makeExecutableSchema } from '@graphql-tools/schema';
+import stringify from 'json-stable-stringify';
+
+// src/index.ts
+function replacer(_, value) {
+  if (typeof value === "bigint") {
+    return value.toString() + "n";
+  }
+  return value;
+}
+var cacheKeyFn = (obj) => stringify(obj, { replacer });
+
+// src/loaders/account.ts
+function applyDefaultArgs({
+  address,
+  commitment,
+  dataSlice,
+  encoding = "jsonParsed",
+  minContextSlot
+}) {
+  return {
+    address,
+    commitment,
+    dataSlice,
+    encoding,
+    minContextSlot
+  };
+}
+async function loadAccount(rpc, { address, ...config }) {
+  return await rpc.getAccountInfo(address, config).send().then((res) => res.value);
+}
+function createAccountBatchLoadFn(rpc) {
+  const resolveAccountUsingRpc = loadAccount.bind(null, rpc);
+  return async (accountQueryArgs) => {
+    return await Promise.all(
+      accountQueryArgs.map(async (args) => await resolveAccountUsingRpc(applyDefaultArgs(args)))
+    );
+  };
+}
+function createAccountLoader(rpc) {
+  const loader = new DataLoader(createAccountBatchLoadFn(rpc), { cacheKeyFn });
+  return {
+    load: async (args) => loader.load(applyDefaultArgs(args))
+  };
+}
+function applyDefaultArgs2({
+  slot,
+  commitment,
+  encoding = "jsonParsed",
+  maxSupportedTransactionVersion = 0,
+  rewards,
+  transactionDetails = "full"
+}) {
+  return {
+    commitment,
+    encoding,
+    maxSupportedTransactionVersion,
+    rewards,
+    slot,
+    transactionDetails
+  };
+}
+async function loadBlock(rpc, { slot, ...config }) {
+  return await rpc.getBlock(
+    slot,
+    // @ts-expect-error FIX ME: https://github.com/solana-labs/solana-web3.js/pull/2052
+    config
+  ).send();
+}
+function createBlockBatchLoadFn(rpc) {
+  const resolveBlockUsingRpc = loadBlock.bind(null, rpc);
+  return async (blockQueryArgs) => {
+    return await Promise.all(blockQueryArgs.map(async (args) => await resolveBlockUsingRpc(applyDefaultArgs2(args))));
+  };
+}
+function createBlockLoader(rpc) {
+  const loader = new DataLoader(createBlockBatchLoadFn(rpc), { cacheKeyFn });
+  return {
+    load: async (args) => loader.load(applyDefaultArgs2(args))
+  };
+}
+function applyDefaultArgs3({
+  commitment,
+  dataSlice,
+  encoding = "jsonParsed",
+  filters,
+  minContextSlot,
+  programAddress
+}) {
+  return {
+    commitment,
+    dataSlice,
+    encoding,
+    filters,
+    minContextSlot,
+    programAddress
+  };
+}
+async function loadProgramAccounts(rpc, { programAddress, ...config }) {
+  return await rpc.getProgramAccounts(
+    programAddress,
+    // @ts-expect-error FIX ME: https://github.com/solana-labs/solana-web3.js/pull/2052
+    config
+  ).send();
+}
+function createProgramAccountsBatchLoadFn(rpc) {
+  const resolveProgramAccountsUsingRpc = loadProgramAccounts.bind(null, rpc);
+  return async (programAccountsQueryArgs) => {
+    return await Promise.all(
+      programAccountsQueryArgs.map(async (args) => await resolveProgramAccountsUsingRpc(applyDefaultArgs3(args)))
+    );
+  };
+}
+function createProgramAccountsLoader(rpc) {
+  const loader = new DataLoader(createProgramAccountsBatchLoadFn(rpc), { cacheKeyFn });
+  return {
+    load: async (args) => loader.load(applyDefaultArgs3(args))
+  };
+}
+function applyDefaultArgs4({
+  commitment,
+  encoding = "jsonParsed",
+  signature
+}) {
+  return {
+    commitment,
+    encoding,
+    signature
+  };
+}
+async function loadTransaction(rpc, { signature, ...config }) {
+  return await rpc.getTransaction(
+    signature,
+    // @ts-expect-error FIX ME: https://github.com/solana-labs/solana-web3.js/pull/2052
+    config
+  ).send();
+}
+function createTransactionBatchLoadFn(rpc) {
+  const resolveTransactionUsingRpc = loadTransaction.bind(null, rpc);
+  return async (transactionQueryArgs) => {
+    return await Promise.all(
+      transactionQueryArgs.map(async (args) => await resolveTransactionUsingRpc(applyDefaultArgs4(args)))
+    );
+  };
+}
+function createTransactionLoader(rpc) {
+  const loader = new DataLoader(createTransactionBatchLoadFn(rpc), { cacheKeyFn });
+  return {
+    load: async (args) => loader.load(applyDefaultArgs4(args))
+  };
+}
 
-// src/rpc.ts
+// src/context.ts
+function createSolanaGraphQLContext(rpc) {
+  return {
+    loaders: {
+      account: createAccountLoader(rpc),
+      block: createBlockLoader(rpc),
+      programAccounts: createProgramAccountsLoader(rpc),
+      transaction: createTransactionLoader(rpc)
+    }
+  };
+}
 
-// src/loaders/common/resolve-info.ts
+// src/resolvers/resolve-info.ts
 function onlyPresentFieldRequested(fieldName, info) {
   if (info && info.fieldNodes[0].selectionSet) {
     const selectionSet = info.fieldNodes[0].selectionSet;
@@ -22,7 +181,7 @@ function onlyPresentFieldRequested(fieldName, info) {
   return false;
 }
 
-// src/loaders/transformers/account.ts
+// src/resolvers/account.ts
 function transformParsedAccountData(parsedAccountData) {
   const {
     parsed: { info: result, type: accountType },
@@ -37,7 +196,7 @@ function transformParsedAccountData(parsedAccountData) {
 function transformLoadedAccount({
   account,
   address,
-  encoding
+  encoding = "jsonParsed"
 }) {
   const [
     // The account's data, either encoded or parsed.
@@ -67,44 +226,112 @@ function transformLoadedAccount({
     ...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;
-  });
-  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)));
+var resolveAccount = (fieldName) => {
+  return async (parent, args, context, info) => {
+    const address = fieldName ? parent[fieldName] : args.address;
+    if (!address) {
+      return null;
+    }
+    if (onlyPresentFieldRequested("address", info)) {
+      return { address };
+    }
+    const account = await context.loaders.account.load({ ...args, address });
+    return account === null ? { address } : transformLoadedAccount({ account, address, encoding: args.encoding });
   };
-}
-function createAccountLoader(rpc) {
-  const loader = new DataLoader(createAccountBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify });
-  return {
-    load: async (args, info) => {
-      if (onlyPresentFieldRequested("address", info)) {
-        return { address: args.address };
+};
+var accountResolvers = {
+  Account: {
+    __resolveType(account) {
+      if (account.encoding === "base58") {
+        return "AccountBase58";
+      }
+      if (account.encoding === "base64") {
+        return "AccountBase64";
+      }
+      if (account.encoding === "base64+zstd") {
+        return "AccountBase64Zstd";
+      }
+      if (account.encoding === "jsonParsed") {
+        if (account.programName === "nonce") {
+          return "NonceAccount";
+        }
+        if (account.accountType === "mint" && account.programName === "spl-token") {
+          return "MintAccount";
+        }
+        if (account.accountType === "account" && account.programName === "spl-token") {
+          return "TokenAccount";
+        }
+        if (account.programName === "stake") {
+          return "StakeAccount";
+        }
+        if (account.accountType === "vote" && account.programName === "vote") {
+          return "VoteAccount";
+        }
+        if (account.accountType === "lookupTable" && account.programName === "address-lookup-table") {
+          return "LookupTableAccount";
+        }
       }
-      return loader.load(normalizeArgs(args));
+      return "AccountBase64";
     }
-  };
-}
+  },
+  AccountBase58: {
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  AccountBase64: {
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  AccountBase64Zstd: {
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  LookupTableAccount: {
+    authority: resolveAccount("authority"),
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  MintAccount: {
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  NonceAccount: {
+    authority: resolveAccount("authority"),
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  StakeAccount: {
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  StakeAccountDataMetaAuthorized: {
+    staker: resolveAccount("staker"),
+    withdrawer: resolveAccount("withdrawer")
+  },
+  StakeAccountDataMetaLockup: {
+    custodian: resolveAccount("custodian")
+  },
+  StakeAccountDataStakeDelegation: {
+    voter: resolveAccount("voter")
+  },
+  TokenAccount: {
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner"),
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  VoteAccount: {
+    authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
+    node: resolveAccount("nodePubkey"),
+    ownerProgram: resolveAccount("ownerProgram")
+  },
+  VoteAccountDataAuthorizedVoter: {
+    authorizedVoter: resolveAccount("authorizedVoter")
+  }
+};
 
-// src/loaders/transformers/transaction.ts
+// src/resolvers/transaction.ts
 function transformParsedInstruction(parsedInstruction) {
   if ("parsed" in parsedInstruction) {
+    if (typeof parsedInstruction.parsed === "string" && parsedInstruction.program === "spl-memo") {
+      const { parsed: memo, program: programName2, programId: programId2 } = parsedInstruction;
+      const instructionType2 = "memo";
+      return { instructionType: instructionType2, memo, programId: programId2, programName: programName2 };
+    }
     const {
       parsed: { info: data, type: instructionType },
       program: programName,
@@ -125,7 +352,10 @@ function transformParsedTransaction(parsedTransaction) {
   });
   return [transactionData, transactionMeta];
 }
-function transformLoadedTransaction({ encoding, transaction }) {
+function transformLoadedTransaction({
+  encoding = "jsonParsed",
+  transaction
+}) {
   const [transactionData, transactionMeta] = Array.isArray(transaction.transaction) ? (
     // The requested encoding is base58 or base64.
     [transaction.transaction[0], transaction.meta]
@@ -139,15 +369,57 @@ function transformLoadedTransaction({ encoding, transaction }) {
   transaction.meta = transactionMeta;
   return transaction;
 }
+function resolveTransaction(fieldName) {
+  return async (parent, args, context, info) => {
+    const signature = fieldName ? parent[fieldName] : args.signature;
+    if (!signature) {
+      return null;
+    }
+    if (onlyPresentFieldRequested("signature", info)) {
+      return { signature };
+    }
+    const transaction = await context.loaders.transaction.load({ ...args, signature });
+    if (!transaction) {
+      return null;
+    }
+    if (args.encoding !== "jsonParsed") {
+      const transactionJsonParsed = await context.loaders.transaction.load({
+        ...args,
+        encoding: "jsonParsed",
+        signature
+      });
+      if (transactionJsonParsed === null) {
+        return null;
+      }
+      transaction.meta = transactionJsonParsed.meta;
+    }
+    return transformLoadedTransaction({ encoding: args.encoding, transaction });
+  };
+}
+var transactionResolvers = {
+  Transaction: {
+    __resolveType(transaction) {
+      switch (transaction.encoding) {
+        case "base58":
+          return "TransactionBase58";
+        case "base64":
+          return "TransactionBase64";
+        default:
+          return "TransactionParsed";
+      }
+    }
+  }
+};
 
-// src/loaders/transformers/block.ts
+// src/resolvers/block.ts
 function transformLoadedBlock({
-  encoding,
   block,
-  transactionDetails
+  encoding = "jsonParsed",
+  transactionDetails = "full"
 }) {
+  const transformedBlock = block;
   if (typeof block === "object" && "transactions" in block) {
-    block.transactions = block.transactions.map((transaction) => {
+    transformedBlock.transactions = block.transactions.map((transaction) => {
       if (transactionDetails === "accounts") {
         return {
           data: transaction.transaction,
@@ -163,1544 +435,390 @@ function transformLoadedBlock({
   block.transactionDetails = transactionDetails;
   return block;
 }
-
-// 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(createBlockBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify });
-  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;
+var resolveBlock = (fieldName) => {
+  return async (parent, args, context, info) => {
+    const slot = fieldName ? parent[fieldName] : args.slot;
+    if (!slot) {
+      return null;
     }
-    return res;
-  }).catch((e) => {
-    throw e;
-  });
-  return programAccounts.map(
-    (programAccount) => transformLoadedAccount({
-      account: programAccount.account,
-      address: programAccount.pubkey,
-      encoding: config.encoding
-    })
-  );
-}
-function createProgramAccountsBatchLoadFn(rpc) {
-  const resolveProgramAccountsUsingRpc = loadProgramAccounts.bind(null, rpc);
-  return async (programAccountsQueryArgs) => {
-    return await Promise.all(
-      programAccountsQueryArgs.map(async (args) => await resolveProgramAccountsUsingRpc(args))
-    );
-  };
-}
-function createProgramAccountsLoader(rpc) {
-  const loader = new DataLoader(createProgramAccountsBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify });
-  return {
-    load: async (args, info) => {
-      if (onlyPresentFieldRequested("programAddress", info)) {
-        return { programAddress: args.programAddress };
-      }
-      return loader.load(normalizeArgs3(args));
+    if (onlyPresentFieldRequested("slot", info)) {
+      return { slot };
     }
-  };
-}
-function normalizeArgs4({ commitment = "confirmed", encoding = "jsonParsed", signature }) {
-  return {
-    commitment,
-    encoding,
-    // Always use 0 to avoid silly errors
-    maxSupportedTransactionVersion: 0,
-    signature
-  };
-}
-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 transactionJsonParsed = await rpc.getTransaction(signature, config).send().catch((e) => {
-      throw e;
-    });
-    if (transactionJsonParsed === null) {
+    const block = await context.loaders.block.load({ ...args, slot });
+    if (block === 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)));
+    const { encoding, transactionDetails } = args;
+    return transformLoadedBlock({ block, encoding, transactionDetails });
   };
-}
-function createTransactionLoader(rpc) {
-  const loader = new DataLoader(createTransactionBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify });
-  return {
-    load: async (args, info) => {
-      if (onlyPresentFieldRequested("signature", info)) {
-        return { signature: args.signature };
+};
+var blockResolvers = {
+  Block: {
+    __resolveType(block) {
+      switch (block.transactionDetails) {
+        case "accounts":
+          return "BlockWithAccounts";
+        case "none":
+          return "BlockWithNone";
+        case "signatures":
+          return "BlockWithSignatures";
+        default:
+          return "BlockWithFull";
       }
-      return loader.load(normalizeArgs4(args));
     }
-  };
-}
-
-// src/context.ts
-function createSolanaGraphQLContext(rpc) {
-  return {
-    loaders: {
-      account: createAccountLoader(rpc),
-      block: createBlockLoader(rpc),
-      programAccounts: createProgramAccountsLoader(rpc),
-      transaction: createTransactionLoader(rpc)
-    },
-    rpc
-  };
-}
-
-// 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);
+  }
 };
 
-// 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";
-      }
-      if (account.encoding === "base64") {
-        return "AccountBase64";
-      }
-      if (account.encoding === "base64+zstd") {
-        return "AccountBase64Zstd";
-      }
-      if (account.encoding === "jsonParsed") {
-        if (account.programName === "nonce") {
-          return "NonceAccount";
-        }
-        if (account.accountType === "mint" && account.programName === "spl-token") {
-          return "MintAccount";
-        }
-        if (account.accountType === "account" && account.programName === "spl-token") {
-          return "TokenAccount";
-        }
-        if (account.programName === "stake") {
-          return "StakeAccount";
-        }
-        if (account.accountType === "vote" && account.programName === "vote") {
-          return "VoteAccount";
-        }
-        if (account.accountType === "lookupTable" && account.programName === "address-lookup-table") {
-          return "LookupTableAccount";
-        }
-      }
-      return "AccountBase64";
-    }
+// src/resolvers/instruction.ts
+var instructionResolvers = {
+  AdvanceNonceAccountInstruction: {
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
   },
-  AccountBase58: {
-    ownerProgram: resolveAccount("ownerProgram")
+  AllocateInstruction: {
+    account: resolveAccount("account")
   },
-  AccountBase64: {
-    ownerProgram: resolveAccount("ownerProgram")
+  AllocateWithSeedInstruction: {
+    account: resolveAccount("account"),
+    owner: resolveAccount("owner")
   },
-  AccountBase64Zstd: {
-    ownerProgram: resolveAccount("ownerProgram")
+  AssignInstruction: {
+    account: resolveAccount("account"),
+    owner: resolveAccount("owner")
   },
-  NonceAccount: {
+  AssignWithSeedInstruction: {
+    account: resolveAccount("account"),
+    owner: resolveAccount("owner")
+  },
+  AuthorizeNonceAccountInstruction: {
+    newAuthorized: resolveAccount("newAuthorized"),
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  },
+  BpfLoaderFinalizeInstruction: {
+    account: resolveAccount("account")
+  },
+  BpfLoaderWriteInstruction: {
+    account: resolveAccount("account")
+  },
+  BpfUpgradeableLoaderCloseInstruction: {
+    account: resolveAccount("account"),
     authority: resolveAccount("authority"),
-    ownerProgram: resolveAccount("ownerProgram")
+    programAccount: resolveAccount("programAccount"),
+    recipient: resolveAccount("recipient")
   },
-  LookupTableAccount: {
+  BpfUpgradeableLoaderDeployWithMaxDataLenInstruction: {
     authority: resolveAccount("authority"),
-    ownerProgram: resolveAccount("ownerProgram")
+    bufferAccount: resolveAccount("bufferAccount"),
+    payerAccount: resolveAccount("payerAccount"),
+    programAccount: resolveAccount("programAccount"),
+    programDataAccount: resolveAccount("programDataAccount")
   },
-  MintAccount: {
-    freezeAuthority: resolveAccount("freezeAuthority"),
-    mintAuthority: resolveAccount("mintAuthority"),
-    ownerProgram: resolveAccount("ownerProgram")
+  BpfUpgradeableLoaderExtendProgramInstruction: {
+    payerAccount: resolveAccount("payerAccount"),
+    programAccount: resolveAccount("programAccount"),
+    programDataAccount: resolveAccount("programDataAccount"),
+    systemProgram: resolveAccount("systemProgram")
   },
-  TokenAccount: {
-    mint: resolveAccount("mint"),
+  BpfUpgradeableLoaderInitializeBufferInstruction: {
+    account: resolveAccount("account")
+  },
+  BpfUpgradeableLoaderSetAuthorityCheckedInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  BpfUpgradeableLoaderSetAuthorityInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  BpfUpgradeableLoaderUpgradeInstruction: {
+    authority: resolveAccount("authority"),
+    bufferAccount: resolveAccount("bufferAccount"),
+    programAccount: resolveAccount("programAccount"),
+    programDataAccount: resolveAccount("programDataAccount")
+  },
+  BpfUpgradeableLoaderWriteInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority")
+  },
+  CloseLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority"),
+    recipient: resolveAccount("recipient")
+  },
+  CreateAccountInstruction: {
+    newAccount: resolveAccount("newAccount"),
     owner: resolveAccount("owner"),
-    ownerProgram: resolveAccount("ownerProgram")
+    source: resolveAccount("source")
   },
-  StakeAccountDataMetaAuthorized: {
-    staker: resolveAccount("staker"),
-    withdrawer: resolveAccount("withdrawer")
+  CreateAccountWithSeedInstruction: {
+    base: resolveAccount("base"),
+    owner: resolveAccount("owner"),
+    seed: resolveAccount("seed")
   },
-  StakeAccountDataMetaLockup: {
+  CreateLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority"),
+    payerAccount: resolveAccount("payerAccount"),
+    systemProgram: resolveAccount("systemProgram")
+  },
+  DeactivateLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority")
+  },
+  ExtendLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority"),
+    payerAccount: resolveAccount("payerAccount"),
+    systemProgram: resolveAccount("systemProgram")
+  },
+  FreezeLookupTableInstruction: {
+    lookupTableAccount: resolveAccount("lookupTableAccount"),
+    lookupTableAuthority: resolveAccount("lookupTableAuthority")
+  },
+  InitializeNonceAccountInstruction: {
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  },
+  Lockup: {
     custodian: resolveAccount("custodian")
   },
-  StakeAccountDataStakeDelegation: {
-    voter: resolveAccount("voter")
+  SplAssociatedTokenCreateIdempotentInstruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    source: resolveAccount("source"),
+    systemProgram: resolveAccount("systemProgram"),
+    tokenProgram: resolveAccount("tokenProgram"),
+    wallet: resolveAccount("wallet")
   },
-  StakeAccount: {
-    ownerProgram: resolveAccount("ownerProgram")
+  SplAssociatedTokenCreateInstruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    source: resolveAccount("source"),
+    systemProgram: resolveAccount("systemProgram"),
+    tokenProgram: resolveAccount("tokenProgram"),
+    wallet: resolveAccount("wallet")
   },
-  VoteAccountDataAuthorizedVoter: {
-    authorizedVoter: resolveAccount("authorizedVoter")
+  SplAssociatedTokenRecoverNestedInstruction: {
+    destination: resolveAccount("destination"),
+    nestedMint: resolveAccount("nestedMint"),
+    nestedOwner: resolveAccount("nestedOwner"),
+    nestedSource: resolveAccount("nestedSource"),
+    ownerMint: resolveAccount("ownerMint"),
+    tokenProgram: resolveAccount("tokenProgram"),
+    wallet: resolveAccount("wallet")
   },
-  VoteAccount: {
-    authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
-    node: resolveAccount("nodePubkey"),
-    ownerProgram: resolveAccount("ownerProgram")
-  }
-};
-
-// 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";
-      }
-    }
-  }
-};
-
-// 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 === Kind.STRING) {
-      return ast.value.toString();
-    }
-    return null;
+  SplTokenAmountToUiAmountInstruction: {
+    mint: resolveAccount("mint")
   },
-  __parseValue(value) {
-    return value;
+  SplTokenApproveCheckedInstruction: {
+    delegate: resolveAccount("delegate"),
+    mint: resolveAccount("mint"),
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
   },
-  __serialize(value) {
-    return value;
-  }
-};
-var scalarResolvers = {
-  Address: stringScalarAlias,
-  Base58EncodedBytes: stringScalarAlias,
-  Base64EncodedBytes: stringScalarAlias,
-  Base64ZstdEncodedBytes: stringScalarAlias,
-  BigInt: {
-    __parseLiteral(ast) {
-      if (ast.kind === Kind.STRING) {
-        return BigInt(ast.value);
-      }
-      return null;
-    },
-    __parseValue(value) {
-      return BigInt(value);
-    },
-    __serialize(value) {
-      return BigInt(value);
-    }
-  }
-};
-
-// 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"
+  SplTokenApproveInstruction: {
+    delegate: resolveAccount("delegate"),
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
   },
-  TokenBalance: {
+  SplTokenBurnCheckedInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    multisigAuthority: resolveAccount("multisigAuthority")
+  },
+  SplTokenBurnInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
     mint: resolveAccount("mint"),
+    multisigAuthority: resolveAccount("multisigAuthority")
+  },
+  SplTokenCloseAccountInstruction: {
+    account: resolveAccount("account"),
+    destination: resolveAccount("destination"),
+    multisigOwner: resolveAccount("multisigOwner"),
     owner: resolveAccount("owner")
   },
-  TransactionEncoding: {
-    BASE_58: "base58",
-    BASE_64: "base64",
-    PARSED: "jsonParsed"
+  SplTokenFreezeAccountInstruction: {
+    account: resolveAccount("account"),
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    multisigFreezeAuthority: resolveAccount("multisigFreezeAuthority")
+  },
+  SplTokenGetAccountDataSizeInstruction: {
+    mint: resolveAccount("mint")
+  },
+  SplTokenInitializeAccount2Instruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner")
+  },
+  SplTokenInitializeAccount3Instruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner")
+  },
+  SplTokenInitializeAccountInstruction: {
+    account: resolveAccount("account"),
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner")
+  },
+  SplTokenInitializeMint2Instruction: {
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority")
+  },
+  SplTokenInitializeMintCloseAuthorityInstruction: {
+    mint: resolveAccount("mint"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  SplTokenInitializeMintInstruction: {
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority")
+  },
+  SplTokenInitializeMultisig2Instruction: {
+    multisig: resolveAccount("multisig")
+  },
+  SplTokenInitializeMultisigInstruction: {
+    multisig: resolveAccount("multisig")
+  },
+  SplTokenMintToCheckedInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    multisigMintAuthority: resolveAccount("multisigMintAuthority")
+  },
+  SplTokenMintToInstruction: {
+    account: resolveAccount("account"),
+    authority: resolveAccount("authority"),
+    mint: resolveAccount("mint"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    multisigMintAuthority: resolveAccount("multisigMintAuthority")
+  },
+  SplTokenRevokeInstruction: {
+    multisigOwner: resolveAccount("multisigOwner"),
+    owner: resolveAccount("owner"),
+    source: resolveAccount("source")
+  },
+  SplTokenSetAuthorityInstruction: {
+    authority: resolveAccount("authority"),
+    multisigAuthority: resolveAccount("multisigAuthority"),
+    newAuthority: resolveAccount("newAuthority")
+  },
+  SplTokenSyncNativeInstruction: {
+    account: resolveAccount("account")
+  },
+  SplTokenThawAccountInstruction: {
+    account: resolveAccount("account"),
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mint: resolveAccount("mint"),
+    multisigFreezeAuthority: resolveAccount("multisigFreezeAuthority")
+  },
+  SplTokenTransferCheckedInstruction: {
+    authority: resolveAccount("authority"),
+    destination: resolveAccount("destination"),
+    mint: resolveAccount("mint"),
+    multisigAuthority: resolveAccount("multisigAuthority"),
+    source: resolveAccount("source")
+  },
+  SplTokenTransferInstruction: {
+    authority: resolveAccount("authority"),
+    destination: resolveAccount("destination"),
+    multisigAuthority: resolveAccount("multisigAuthority"),
+    source: resolveAccount("source")
+  },
+  SplTokenUiAmountToAmountInstruction: {
+    mint: resolveAccount("mint")
+  },
+  StakeAuthorizeCheckedInstruction: {
+    authority: resolveAccount("authority"),
+    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")
+  },
+  StakeAuthorizeInstruction: {
+    authority: resolveAccount("authority"),
+    custodian: resolveAccount("custodian"),
+    newAuthority: resolveAccount("newAuthority"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeAuthorizeWithSeedInstruction: {
+    authorityBase: resolveAccount("authorityBase"),
+    authorityOwner: resolveAccount("authorityOwner"),
+    custodian: resolveAccount("custodian"),
+    newAuthorized: resolveAccount("newAuthorized"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeDeactivateDelinquentInstruction: {
+    referenceVoteAccount: resolveAccount("referenceVoteAccount"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  StakeDeactivateInstruction: {
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority")
+  },
+  StakeDelegateStakeInstruction: {
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority"),
+    stakeConfigAccount: resolveAccount("stakeConfigAccount"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  StakeInitializeCheckedInstructionDataAuthorized: {
+    staker: resolveAccount("staker"),
+    withdrawer: resolveAccount("withdrawer")
+  },
+  StakeInitializeInstruction: {
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeInitializeInstructionDataAuthorized: {
+    staker: resolveAccount("staker"),
+    withdrawer: resolveAccount("withdrawer")
+  },
+  StakeMergeInstruction: {
+    destination: resolveAccount("destination"),
+    source: resolveAccount("source"),
+    stakeAuthority: resolveAccount("stakeAuthority")
+  },
+  StakeRedelegateInstruction: {
+    newStakeAccount: resolveAccount("newStakeAccount"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority"),
+    stakeConfigAccount: resolveAccount("stakeConfigAccount"),
+    voteAccount: resolveAccount("voteAccount")
+  },
+  StakeSetLockupCheckedInstruction: {
+    custodian: resolveAccount("custodian"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeSetLockupInstruction: {
+    custodian: resolveAccount("custodian"),
+    stakeAccount: resolveAccount("stakeAccount")
+  },
+  StakeSplitInstruction: {
+    newSplitAccount: resolveAccount("newSplitAccount"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    stakeAuthority: resolveAccount("stakeAuthority")
+  },
+  StakeWithdrawInstruction: {
+    destination: resolveAccount("destination"),
+    stakeAccount: resolveAccount("stakeAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
   },
-  TransactionVersion: {
-    LEGACY: "legacy",
-    ZERO: 0
-  }
-};
-
-// 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) {
@@ -1965,391 +1083,66 @@ var instructionResolvers = {
           if (instruction.instructionType === "compactupdatevotestateswitch") {
             return "VoteCompactUpdateVoteStateSwitchInstruction";
           }
-          if (instruction.instructionType === "withdraw") {
-            return "VoteWithdrawInstruction";
-          }
-          if (instruction.instructionType === "updateValidatorIdentity") {
-            return "VoteUpdateValidatorIdentityInstruction";
-          }
-          if (instruction.instructionType === "updateCommission") {
-            return "VoteUpdateCommissionInstruction";
-          }
-          if (instruction.instructionType === "voteSwitch") {
-            return "VoteVoteSwitchInstruction";
-          }
-          if (instruction.instructionType === "authorizeChecked") {
-            return "VoteAuthorizeCheckedInstruction";
-          }
-        }
-      }
-      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")
+          if (instruction.instructionType === "withdraw") {
+            return "VoteWithdrawInstruction";
+          }
+          if (instruction.instructionType === "updateValidatorIdentity") {
+            return "VoteUpdateValidatorIdentityInstruction";
+          }
+          if (instruction.instructionType === "updateCommission") {
+            return "VoteUpdateCommissionInstruction";
+          }
+          if (instruction.instructionType === "voteSwitch") {
+            return "VoteVoteSwitchInstruction";
+          }
+          if (instruction.instructionType === "authorizeChecked") {
+            return "VoteAuthorizeCheckedInstruction";
+          }
+        }
+      }
+      return "GenericInstruction";
+    }
   },
-  SplTokenTransferCheckedInstruction: {
-    authority: resolveAccount("authority"),
+  TransferInstruction: {
     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")
+  TransferWithSeedInstruction: {
+    destination: resolveAccount("destination"),
+    source: resolveAccount("source"),
+    sourceOwner: resolveAccount("sourceOwner")
   },
-  StakeInitializeInstruction: {
-    stakeAccount: resolveAccount("stakeAccount")
+  UpgradeNonceAccountInstruction: {
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
   },
-  StakeAuthorizeInstruction: {
+  VoteAuthorizeCheckedInstruction: {
     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"),
+  VoteAuthorizeCheckedWithSeedInstruction: {
     authorityOwner: resolveAccount("authorityOwner"),
-    custodian: resolveAccount("custodian"),
-    newAuthorized: resolveAccount("newAuthorized"),
-    stakeAccount: resolveAccount("stakeAccount")
-  },
-  StakeInitializeCheckedInstructionDataAuthorized: {
-    staker: resolveAccount("staker"),
-    withdrawer: resolveAccount("withdrawer")
+    newAuthority: resolveAccount("newAuthority"),
+    voteAccount: resolveAccount("voteAccount")
   },
-  StakeAuthorizeCheckedInstruction: {
+  VoteAuthorizeInstruction: {
     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"),
+  VoteAuthorizeWithSeedInstruction: {
+    authorityOwner: resolveAccount("authorityOwner"),
+    newAuthority: resolveAccount("newAuthority"),
     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")
+  VoteCompactUpdateVoteStateInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
   },
-  TransferWithSeedInstruction: {
-    destination: resolveAccount("destination"),
-    source: resolveAccount("source"),
-    sourceOwner: resolveAccount("sourceOwner")
+  VoteCompactUpdateVoteStateSwitchInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    voteAuthority: resolveAccount("voteAuthority")
   },
   VoteInitializeAccountInstruction: {
     authorizedVoter: resolveAccount("authorizedVoter"),
@@ -2357,24 +1150,14 @@ var instructionResolvers = {
     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")
+  VoteUpdateCommissionInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
   },
-  VoteVoteInstruction: {
+  VoteUpdateValidatorIdentityInstruction: {
+    newValidatorIdentity: resolveAccount("newValidatorIdentity"),
     voteAccount: resolveAccount("voteAccount"),
-    voteAuthority: resolveAccount("voteAuthority")
+    withdrawAuthority: resolveAccount("withdrawAuthority")
   },
   VoteUpdateVoteStateInstruction: {
     voteAccount: resolveAccount("voteAccount"),
@@ -2384,38 +1167,1602 @@ var instructionResolvers = {
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
-  VoteCompactUpdateVoteStateInstruction: {
+  VoteVoteInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
-  VoteCompactUpdateVoteStateSwitchInstruction: {
+  VoteVoteSwitchInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
-  VoteWithdrawInstruction: {
-    voteAccount: resolveAccount("voteAccount"),
-    withdrawAuthority: resolveAccount("withdrawAuthority")
+  VoteWithdrawInstruction: {
+    voteAccount: resolveAccount("voteAccount"),
+    withdrawAuthority: resolveAccount("withdrawAuthority")
+  },
+  WithdrawNonceAccountInstruction: {
+    destination: resolveAccount("destination"),
+    nonceAccount: resolveAccount("nonceAccount"),
+    nonceAuthority: resolveAccount("nonceAuthority")
+  }
+};
+
+// src/resolvers/program-accounts.ts
+function resolveProgramAccounts(fieldName) {
+  return async (parent, args, context, info) => {
+    const programAddress = fieldName ? parent[fieldName] : args.programAddress;
+    if (!programAddress) {
+      return null;
+    }
+    if (onlyPresentFieldRequested("programAddress", info)) {
+      return { programAddress };
+    }
+    const programAccounts = await context.loaders.programAccounts.load({ ...args, programAddress });
+    return programAccounts === null ? { programAddress } : programAccounts.map(
+      (programAccount) => transformLoadedAccount({
+        account: programAccount.account,
+        address: programAccount.pubkey,
+        encoding: args.encoding
+      })
+    );
+  };
+}
+
+// src/resolvers/root.ts
+var rootResolvers = {
+  Query: {
+    account: resolveAccount(),
+    block: resolveBlock(),
+    programAccounts: resolveProgramAccounts(),
+    transaction: resolveTransaction()
+  }
+};
+var stringScalarAlias = {
+  __parseLiteral(ast) {
+    if (ast.kind === Kind.STRING) {
+      return ast.value.toString();
+    }
+    return null;
+  },
+  __parseValue(value) {
+    return value;
   },
-  VoteUpdateValidatorIdentityInstruction: {
-    newValidatorIdentity: resolveAccount("newValidatorIdentity"),
-    voteAccount: resolveAccount("voteAccount"),
-    withdrawAuthority: resolveAccount("withdrawAuthority")
+  __serialize(value) {
+    return value;
+  }
+};
+var scalarResolvers = {
+  Address: stringScalarAlias,
+  Base58EncodedBytes: stringScalarAlias,
+  Base64EncodedBytes: stringScalarAlias,
+  Base64ZstdEncodedBytes: stringScalarAlias,
+  BigInt: {
+    __parseLiteral(ast) {
+      if (ast.kind === Kind.STRING) {
+        return BigInt(ast.value);
+      }
+      return null;
+    },
+    __parseValue(value) {
+      return BigInt(value);
+    },
+    __serialize(value) {
+      return BigInt(value);
+    }
+  }
+};
+
+// src/resolvers/types.ts
+var commonTypeResolvers = {
+  AccountEncoding: {
+    BASE_58: "base58",
+    BASE_64: "base64",
+    BASE_64_ZSTD: "base64+zstd",
+    PARSED: "jsonParsed"
   },
-  VoteUpdateCommissionInstruction: {
-    voteAccount: resolveAccount("voteAccount"),
-    withdrawAuthority: resolveAccount("withdrawAuthority")
+  TokenBalance: {
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner")
   },
-  VoteVoteSwitchInstruction: {
-    voteAccount: resolveAccount("voteAccount"),
-    voteAuthority: resolveAccount("voteAuthority")
+  TransactionEncoding: {
+    BASE_58: "base58",
+    BASE_64: "base64",
+    PARSED: "jsonParsed"
   },
-  VoteAuthorizeCheckedInstruction: {
-    authority: resolveAccount("authority"),
-    newAuthority: resolveAccount("newAuthority"),
-    voteAccount: resolveAccount("voteAccount")
+  TransactionVersion: {
+    LEGACY: "legacy",
+    ZERO: 0
   }
 };
 
+// src/resolvers/index.ts
+function createSolanaGraphQLResolvers() {
+  return {
+    ...accountResolvers,
+    ...blockResolvers,
+    ...commonTypeResolvers,
+    ...instructionResolvers,
+    ...rootResolvers,
+    ...scalarResolvers,
+    ...transactionResolvers
+  };
+}
+
+// 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
+    }
+
+    type NonceAccountFeeCalculator {
+        lamportsPerSignature: String
+    }
+    """
+    A nonce account
+    """
+    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
+    }
+
+    type StakeAccountDataMetaAuthorized {
+        staker: Account
+        withdrawer: Account
+    }
+    type StakeAccountDataMetaLockup {
+        custodian: Account
+        epoch: BigInt
+        unixTimestamp: BigInt
+    }
+    type StakeAccountDataMeta {
+        authorized: StakeAccountDataMetaAuthorized
+        lockup: StakeAccountDataMetaLockup
+        rentExemptReserve: String
+    }
+    type StakeAccountDataStakeDelegation {
+        activationEpoch: BigInt
+        deactivationEpoch: BigInt
+        stake: String
+        voter: Account
+        warmupCooldownRate: Int
+    }
+    type StakeAccountDataStake {
+        creditsObserved: BigInt
+        delegation: StakeAccountDataStakeDelegation
+    }
+    """
+    A stake account
+    """
+    type StakeAccount implements Account {
+        address: Address
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        meta: StakeAccountDataMeta
+        stake: StakeAccountDataStake
+    }
+
+    type VoteAccountDataAuthorizedVoter {
+        authorizedVoter: Account
+        epoch: BigInt
+    }
+    type VoteAccountDataEpochCredit {
+        credits: String
+        epoch: BigInt
+        previousCredits: String
+    }
+    type VoteAccountDataLastTimestamp {
+        slot: BigInt
+        timestamp: BigInt
+    }
+    type VoteAccountDataVote {
+        confirmationCount: Int
+        slot: BigInt
+    }
+    """
+    A vote account
+    """
+    type VoteAccount implements Account {
+        address: Address
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
+        authorizedVoters: [VoteAccountDataAuthorizedVoter]
+        authorizedWithdrawer: Account
+        commission: Int
+        epochCredits: [VoteAccountDataEpochCredit]
+        lastTimestamp: VoteAccountDataLastTimestamp
+        node: Account
+        priorVoters: [Address]
+        rootSlot: BigInt
+        votes: [VoteAccountDataVote]
+    }
+`
+);
+
+// src/schema/block.ts
+var blockTypeDefs = (
+  /* GraphQL */
+  `
+    type TransactionMetaForAccounts {
+        err: String
+        fee: BigInt
+        postBalances: [BigInt]
+        postTokenBalances: [TokenBalance]
+        preBalances: [BigInt]
+        preTokenBalances: [TokenBalance]
+        status: TransactionStatus
+    }
+
+    type TransactionDataForAccounts {
+        accountKeys: [Address]
+        signatures: [String]
+    }
+
+    type BlockTransactionAccounts {
+        meta: TransactionMetaForAccounts
+        data: TransactionDataForAccounts
+        version: String
+    }
+
+    """
+    Block interface
+    """
+    interface Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: BigInt
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        transactionDetails: String
+    }
+
+    """
+    A block with account transaction details
+    """
+    type BlockWithAccounts implements Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: BigInt
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        transactions: [BlockTransactionAccounts]
+        transactionDetails: String
+    }
+
+    """
+    A block with full transaction details
+    """
+    type BlockWithFull implements Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: BigInt
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        transactions: [Transaction]
+        transactionDetails: String
+    }
+
+    """
+    A block with no transaction details
+    """
+    type BlockWithNone implements Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: BigInt
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        transactionDetails: String
+    }
+
+    """
+    A block with signature transaction details
+    """
+    type BlockWithSignatures implements Block {
+        blockhash: String
+        blockHeight: BigInt
+        blockTime: BigInt
+        parentSlot: BigInt
+        previousBlockhash: String
+        rewards: [Reward]
+        signatures: [String]
+        transactionDetails: String
+    }
+`
+);
+
+// src/schema/common/inputs.ts
+var inputTypeDefs = (
+  /* GraphQL */
+  `
+    input DataSlice {
+        offset: Int
+        length: Int
+    }
+
+    input ProgramAccountsFilter {
+        bytes: BigInt
+        dataSize: BigInt
+        encoding: AccountEncoding
+        offset: BigInt
+    }
+`
+);
+
+// src/schema/common/scalars.ts
+var scalarTypeDefs = (
+  /* GraphQL */
+  `
+    scalar Address
+    scalar Base58EncodedBytes
+    scalar Base64EncodedBytes
+    scalar Base64ZstdEncodedBytes
+    scalar BigInt
+`
+);
+
+// src/schema/common/types.ts
+var commonTypeDefs = (
+  /* GraphQL */
+  `
+    enum AccountEncoding {
+        BASE_58
+        BASE_64
+        BASE_64_ZSTD
+        PARSED
+    }
+
+    enum BlockTransactionDetails {
+        accounts
+        full
+        none
+        signatures
+    }
+
+    enum Commitment {
+        confirmed
+        finalized
+        processed
+    }
+
+    type ReturnData {
+        data: Base64EncodedBytes
+        programId: Address
+    }
+
+    type Reward {
+        commission: Int
+        lamports: BigInt
+        postBalance: BigInt
+        pubkey: Address
+        rewardType: String
+    }
+
+    type TokenAmount {
+        amount: String
+        decimals: Int
+        uiAmount: BigInt
+        uiAmountString: String
+    }
+
+    type TokenBalance {
+        accountIndex: Int
+        mint: Account
+        owner: Account
+        programId: Address
+        uiTokenAmount: TokenAmount
+    }
+
+    enum TransactionEncoding {
+        BASE_58
+        BASE_64
+        PARSED
+    }
+
+    enum TransactionVersion {
+        LEGACY
+        ZERO
+    }
+`
+);
+
+// src/schema/instruction.ts
+var instructionTypeDefs = (
+  /* GraphQL */
+  `
+    """
+    Transaction instruction interface
+    """
+    interface TransactionInstruction {
+        programId: Address
+    }
+
+    """
+    Generic transaction instruction
+    """
+    type GenericInstruction implements TransactionInstruction {
+        accounts: [Address]
+        data: Base64EncodedBytes
+        programId: Address
+    }
+
+    """
+    AddressLookupTable: CreateLookupTable instruction
+    """
+    type CreateLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        bumpSeed: BigInt # FIXME:*
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+        payerAccount: Account
+        recentSlot: BigInt
+        systemProgram: Account
+    }
+
+    """
+    AddressLookupTable: ExtendLookupTable instruction
+    """
+    type ExtendLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+        newAddresses: [Address]
+        payerAccount: Account
+        systemProgram: Account
+    }
+
+    """
+    AddressLookupTable: FreezeLookupTable instruction
+    """
+    type FreezeLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+    }
+
+    """
+    AddressLookupTable: DeactivateLookupTable instruction
+    """
+    type DeactivateLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+    }
+
+    """
+    AddressLookupTable: CloseLookupTable instruction
+    """
+    type CloseLookupTableInstruction implements TransactionInstruction {
+        programId: Address
+        lookupTableAccount: Account
+        lookupTableAuthority: Account
+        recipient: Account
+    }
+
+    """
+    BpfLoader: Write instruction
+    """
+    type BpfLoaderWriteInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        bytes: Base64EncodedBytes
+        offset: BigInt # FIXME:*
+    }
+
+    """
+    BpfLoader: Finalize instruction
+    """
+    type BpfLoaderFinalizeInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    """
+    BpfUpgradeableLoader: InitializeBuffer instruction
+    """
+    type BpfUpgradeableLoaderInitializeBufferInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    """
+    BpfUpgradeableLoader: Write instruction
+    """
+    type BpfUpgradeableLoaderWriteInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        bytes: Base64EncodedBytes
+        offset: BigInt # FIXME:*
+    }
+
+    """
+    BpfUpgradeableLoader: DeployWithMaxDataLen instruction
+    """
+    type BpfUpgradeableLoaderDeployWithMaxDataLenInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        bufferAccount: Account
+        clockSysvar: Address
+        maxDataLen: BigInt
+        payerAccount: Account
+        programAccount: Account
+        programDataAccount: Account
+        rentSysvar: Address
+    }
+
+    """
+    BpfUpgradeableLoader: Upgrade instruction
+    """
+    type BpfUpgradeableLoaderUpgradeInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        bufferAccount: Account
+        clockSysvar: Address
+        programAccount: Account
+        programDataAccount: Account
+        rentSysvar: Address
+        spillAccount: Account
+    }
+
+    """
+    BpfUpgradeableLoader: SetAuthority instruction
+    """
+    type BpfUpgradeableLoaderSetAuthorityInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        newAuthority: Account
+    }
+
+    """
+    BpfUpgradeableLoader: SetAuthorityChecked instruction
+    """
+    type BpfUpgradeableLoaderSetAuthorityCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        newAuthority: Account
+    }
+
+    """
+    BpfUpgradeableLoader: Close instruction
+    """
+    type BpfUpgradeableLoaderCloseInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        programAccount: Account
+        recipient: Account
+    }
+
+    """
+    BpfUpgradeableLoader: ExtendProgram instruction
+    """
+    type BpfUpgradeableLoaderExtendProgramInstruction implements TransactionInstruction {
+        programId: Address
+        additionalBytes: BigInt
+        payerAccount: Account
+        programAccount: Account
+        programDataAccount: Account
+        systemProgram: Account
+    }
+
+    """
+    SplAssociatedTokenAccount: Create instruction
+    """
+    type SplAssociatedTokenCreateInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Address
+        source: Account
+        systemProgram: Account
+        tokenProgram: Account
+        wallet: Account
+    }
+
+    """
+    SplAssociatedTokenAccount: CreateIdempotent instruction
+    """
+    type SplAssociatedTokenCreateIdempotentInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Address
+        source: Account
+        systemProgram: Account
+        tokenProgram: Account
+        wallet: Account
+    }
+
+    """
+    SplAssociatedTokenAccount: RecoverNested instruction
+    """
+    type SplAssociatedTokenRecoverNestedInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        nestedMint: Account
+        nestedOwner: Account
+        nestedSource: Account
+        ownerMint: Account
+        tokenProgram: Account
+        wallet: Account
+    }
+
+    """
+    SplMemo instruction
+    """
+    type SplMemoInstruction implements TransactionInstruction {
+        programId: Address
+        memo: String
+    }
+
+    """
+    SplToken: InitializeMint instruction
+    """
+    type SplTokenInitializeMintInstruction implements TransactionInstruction {
+        programId: Address
+        decimals: BigInt # FIXME:*
+        freezeAuthority: Account
+        mint: Account
+        mintAuthority: Account
+        rentSysvar: Address
+    }
+
+    """
+    SplToken: InitializeMint2 instruction
+    """
+    type SplTokenInitializeMint2Instruction implements TransactionInstruction {
+        programId: Address
+        decimals: BigInt # FIXME:*
+        freezeAuthority: Account
+        mint: Account
+        mintAuthority: Account
+    }
+
+    """
+    SplToken: InitializeAccount instruction
+    """
+    type SplTokenInitializeAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        owner: Account
+        rentSysvar: Address
+    }
+
+    """
+    SplToken: InitializeAccount2 instruction
+    """
+    type SplTokenInitializeAccount2Instruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        owner: Account
+        rentSysvar: Address
+    }
+
+    """
+    SplToken: InitializeAccount3 instruction
+    """
+    type SplTokenInitializeAccount3Instruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        mint: Account
+        owner: Account
+    }
+
+    """
+    SplToken: InitializeMultisig instruction
+    """
+    type SplTokenInitializeMultisigInstruction implements TransactionInstruction {
+        programId: Address
+        m: BigInt # FIXME:*
+        multisig: Account
+        rentSysvar: Address
+        signers: [Address]
+    }
+
+    """
+    SplToken: InitializeMultisig2 instruction
+    """
+    type SplTokenInitializeMultisig2Instruction implements TransactionInstruction {
+        programId: Address
+        m: BigInt # FIXME:*
+        multisig: Account
+        signers: [Address]
+    }
+
+    """
+    SplToken: Transfer instruction
+    """
+    type SplTokenTransferInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        authority: Account
+        destination: Account
+        multisigAuthority: Account
+        source: Account
+    }
+
+    """
+    SplToken: Approve instruction
+    """
+    type SplTokenApproveInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        delegate: Account
+        multisigOwner: Account
+        owner: Account
+        source: Account
+    }
+
+    """
+    SplToken: Revoke instruction
+    """
+    type SplTokenRevokeInstruction implements TransactionInstruction {
+        programId: Address
+        multisigOwner: Account
+        owner: Account
+        source: Account
+    }
+
+    """
+    SplToken: SetAuthority instruction
+    """
+    type SplTokenSetAuthorityInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        multisigAuthority: Account
+        newAuthority: Account
+    }
+
+    """
+    SplToken: MintTo instruction
+    """
+    type SplTokenMintToInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        amount: String
+        authority: Account
+        mint: Account
+        mintAuthority: Account
+        multisigMintAuthority: Account
+    }
+
+    """
+    SplToken: Burn instruction
+    """
+    type SplTokenBurnInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        amount: String
+        authority: Account
+        mint: Account
+        multisigAuthority: Account
+    }
+
+    """
+    SplToken: CloseAccount instruction
+    """
+    type SplTokenCloseAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        destination: Account
+        multisigOwner: Account
+        owner: Account
+    }
+
+    """
+    SplToken: FreezeAccount instruction
+    """
+    type SplTokenFreezeAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        freezeAuthority: Account
+        mint: Account
+        multisigFreezeAuthority: Account
+    }
+
+    """
+    SplToken: ThawAccount instruction
+    """
+    type SplTokenThawAccountInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        freezeAuthority: Account
+        mint: Account
+        multisigFreezeAuthority: Account
+    }
+
+    """
+    SplToken: TransferChecked instruction
+    """
+    type SplTokenTransferCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        authority: Account
+        decimals: BigInt # FIXME:*
+        destination: Account
+        mint: Account
+        multisigAuthority: Account
+        source: Account
+        tokenAmount: String
+    }
+
+    """
+    SplToken: ApproveChecked instruction
+    """
+    type SplTokenApproveCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        delegate: Account
+        mint: Account
+        multisigOwner: Account
+        owner: Account
+        source: Account
+        tokenAmount: String
+    }
+
+    """
+    SplToken: MintToChecked instruction
+    """
+    type SplTokenMintToCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        mint: Account
+        mintAuthority: Account
+        multisigMintAuthority: Account
+        tokenAmount: String
+    }
+
+    """
+    SplToken: BurnChecked instruction
+    """
+    type SplTokenBurnCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        authority: Account
+        mint: Account
+        multisigAuthority: Account
+        tokenAmount: String
+    }
+
+    """
+    SplToken: SyncNative instruction
+    """
+    type SplTokenSyncNativeInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    """
+    SplToken: GetAccountDataSize instruction
+    """
+    type SplTokenGetAccountDataSizeInstruction implements TransactionInstruction {
+        programId: Address
+        extensionTypes: [String]
+        mint: Account
+    }
+
+    """
+    SplToken: InitializeImmutableOwner instruction
+    """
+    type SplTokenInitializeImmutableOwnerInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+    }
+
+    """
+    SplToken: AmountToUiAmount instruction
+    """
+    type SplTokenAmountToUiAmountInstruction implements TransactionInstruction {
+        programId: Address
+        amount: String
+        mint: Account
+    }
+
+    """
+    SplToken: UiAmountToAmount instruction
+    """
+    type SplTokenUiAmountToAmountInstruction implements TransactionInstruction {
+        programId: Address
+        mint: Account
+        uiAmount: String
+    }
+
+    """
+    SplToken: InitializeMintCloseAuthority instruction
+    """
+    type SplTokenInitializeMintCloseAuthorityInstruction implements TransactionInstruction {
+        programId: Address
+        mint: Account
+        newAuthority: Account
+    }
+
+    # TODO: Extensions!
+    # - TransferFeeExtension
+    # - ConfidentialTransferFeeExtension
+    # - DefaultAccountStateExtension
+    # - Reallocate
+    # - MemoTransferExtension
+    # - CreateNativeMint
+    # - InitializeNonTransferableMint
+    # - InterestBearingMintExtension
+    # - CpiGuardExtension
+    # - InitializePermanentDelegate
+    # - TransferHookExtension
+    # - ConfidentialTransferFeeExtension
+    # - WithdrawExcessLamports
+    # - MetadataPointerExtension
+
+    type Lockup {
+        custodian: Account
+        epoch: BigInt
+        unixTimestamp: BigInt
+    }
+
+    """
+    Stake: Initialize instruction
+    """
+    type StakeInitializeInstructionDataAuthorized {
+        staker: Account
+        withdrawer: Account
+    }
+    type StakeInitializeInstruction implements TransactionInstruction {
+        programId: Address
+        authorized: StakeInitializeInstructionDataAuthorized
+        lockup: Lockup
+        rentSysvar: Address
+        stakeAccount: Account
+    }
+
+    """
+    Stake: Authorize instruction
+    """
+    type StakeAuthorizeInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Address
+        custodian: Account
+        newAuthority: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: DelegateStake instruction
+    """
+    type StakeDelegateStakeInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        stakeAccount: Account
+        stakeAuthority: Account
+        stakeConfigAccount: Account
+        stakeHistorySysvar: Address
+        voteAccount: Account
+    }
+
+    """
+    Stake: Split instruction
+    """
+    type StakeSplitInstruction implements TransactionInstruction {
+        programId: Address
+        lamports: BigInt
+        newSplitAccount: Account
+        stakeAccount: Account
+        stakeAuthority: Account
+    }
+
+    """
+    Stake: Withdraw instruction
+    """
+    type StakeWithdrawInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        destination: Account
+        lamports: BigInt
+        stakeAccount: Account
+        withdrawAuthority: Account
+    }
+
+    """
+    Stake: Deactivate instruction
+    """
+    type StakeDeactivateInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        stakeAccount: Account
+        stakeAuthority: Account
+    }
+
+    """
+    Stake: SetLockup instruction
+    """
+    type StakeSetLockupInstruction implements TransactionInstruction {
+        programId: Address
+        custodian: Account
+        lockup: Lockup
+        stakeAccount: Account
+    }
+
+    """
+    Stake: Merge instruction
+    """
+    type StakeMergeInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        destination: Account
+        source: Account
+        stakeAuthority: Account
+        stakeHistorySysvar: Address
+    }
+
+    """
+    Stake: AuthorizeWithSeed instruction
+    """
+    type StakeAuthorizeWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBase: Account
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Address
+        custodian: Account
+        newAuthorized: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: InitializeChecked instruction
+    """
+    type StakeInitializeCheckedInstructionDataAuthorized {
+        staker: Account
+        withdrawer: Account
+    }
+    type StakeInitializeCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        authorized: StakeInitializeCheckedInstructionDataAuthorized
+        lockup: Lockup
+        rentSysvar: Address
+        stakeAccount: Account
+    }
+
+    """
+    Stake: AuthorizeChecked instruction
+    """
+    type StakeAuthorizeCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Address
+        custodian: Account
+        newAuthority: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: AuthorizeCheckedWithSeed instruction
+    """
+    type StakeAuthorizeCheckedWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBase: Account
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Address
+        custodian: Account
+        newAuthorized: Account
+        stakeAccount: Account
+    }
+
+    """
+    Stake: SetLockupChecked instruction
+    """
+    type StakeSetLockupCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        custodian: Account
+        lockup: Lockup
+        stakeAccount: Account
+    }
+
+    """
+    Stake: DeactivateDelinquent instruction
+    """
+    type StakeDeactivateDelinquentInstruction implements TransactionInstruction {
+        programId: Address
+        referenceVoteAccount: Account
+        stakeAccount: Account
+        voteAccount: Account
+    }
+
+    """
+    Stake: Redelegate instruction
+    """
+    type StakeRedelegateInstruction implements TransactionInstruction {
+        programId: Address
+        newStakeAccount: Account
+        stakeAccount: Account
+        stakeAuthority: Account
+        stakeConfigAccount: Account
+        voteAccount: Account
+    }
+
+    """
+    System: CreateAccount instruction
+    """
+    type CreateAccountInstruction implements TransactionInstruction {
+        programId: Address
+        lamports: BigInt
+        newAccount: Account
+        owner: Account
+        source: Account
+        space: BigInt
+    }
+
+    """
+    System: Assign instruction
+    """
+    type AssignInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        owner: Account
+    }
+
+    """
+    System: Transfer instruction
+    """
+    type TransferInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        source: Account
+    }
+
+    """
+    System: CreateAccountWithSeed instruction
+    """
+    type CreateAccountWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        base: Account
+        lamports: BigInt
+        owner: Account
+        seed: String
+        space: BigInt
+    }
+
+    """
+    System: AdvanceNonceAccount instruction
+    """
+    type AdvanceNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        nonceAccount: Account
+        nonceAuthority: Account
+        recentBlockhashesSysvar: Address
+    }
+
+    """
+    System: WithdrawNonceAccount instruction
+    """
+    type WithdrawNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        nonceAccount: Account
+        nonceAuthority: Account
+        recentBlockhashesSysvar: Address
+        rentSysvar: Address
+    }
+
+    """
+    System: InitializeNonceAccount instruction
+    """
+    type InitializeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        nonceAccount: Account
+        nonceAuthority: Account
+        recentBlockhashesSysvar: Address
+        rentSysvar: Address
+    }
+
+    """
+    System: AuthorizeNonceAccount instruction
+    """
+    type AuthorizeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        newAuthorized: Account
+        nonceAccount: Account
+        nonceAuthority: Account
+    }
+
+    """
+    System: UpgradeNonceAccount instruction
+    """
+    type UpgradeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
+        nonceAccount: Account
+        nonceAuthority: Account
+    }
+
+    """
+    System: Allocate instruction
+    """
+    type AllocateInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        space: BigInt
+    }
+
+    """
+    System: AllocateWithSeed instruction
+    """
+    type AllocateWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        base: Address
+        owner: Account
+        seed: String
+        space: BigInt
+    }
+
+    """
+    System: AssignWithSeed instruction
+    """
+    type AssignWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        account: Account
+        base: Address
+        owner: Account
+        seed: String
+    }
+
+    """
+    System: TransferWithSeed instruction
+    """
+    type TransferWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        source: Account
+        sourceBase: Address
+        sourceOwner: Account
+        sourceSeed: String
+    }
+
+    """
+    Vote: InitializeAccount instruction
+    """
+    type VoteInitializeAccountInstruction implements TransactionInstruction {
+        programId: Address
+        authorizedVoter: Account
+        authorizedWithdrawer: Account
+        clockSysvar: Address
+        commission: BigInt # FIXME:*
+        node: Account
+        rentSysvar: Address
+        voteAccount: Account
+    }
+
+    """
+    Vote: Authorize instruction
+    """
+    type VoteAuthorizeInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Address
+        newAuthority: Account
+        voteAccount: Account
+    }
+
+    """
+    Vote: AuthorizeWithSeed instruction
+    """
+    type VoteAuthorizeWithSeedInstruction implements TransactionInstruction {
+        programId: Address
+        authorityBaseKey: String
+        authorityOwner: Account
+        authoritySeed: String
+        authorityType: String
+        clockSysvar: Address
+        newAuthority: Account
+        voteAccount: Account
+    }
+
+    """
+    Vote: AuthorizeCheckedWithSeed instruction
+    """
+    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 instruction
+    """
+    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 instruction
+    """
+    type VoteUpdateVoteStateInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    """
+    Vote: UpdateVoteStateSwitch instruction
+    """
+    type VoteUpdateVoteStateSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    """
+    Vote: CompactUpdateVoteState instruction
+    """
+    type VoteCompactUpdateVoteStateInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    """
+    Vote: CompactUpdateVoteStateSwitch instruction
+    """
+    type VoteCompactUpdateVoteStateSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        hash: String
+        voteAccount: Account
+        voteAuthority: Account
+        voteStateUpdate: VoteStateUpdate
+    }
+
+    """
+    Vote: Withdraw instruction
+    """
+    type VoteWithdrawInstruction implements TransactionInstruction {
+        programId: Address
+        destination: Account
+        lamports: BigInt
+        voteAccount: Account
+        withdrawAuthority: Account
+    }
+
+    """
+    Vote: UpdateValidatorIdentity instruction
+    """
+    type VoteUpdateValidatorIdentityInstruction implements TransactionInstruction {
+        programId: Address
+        newValidatorIdentity: Account
+        voteAccount: Account
+        withdrawAuthority: Account
+    }
+
+    """
+    Vote: UpdateCommission instruction
+    """
+    type VoteUpdateCommissionInstruction implements TransactionInstruction {
+        programId: Address
+        commission: BigInt # FIXME:*
+        voteAccount: Account
+        withdrawAuthority: Account
+    }
+
+    """
+    Vote: VoteSwitch instruction
+    """
+    type VoteVoteSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        hash: String
+        slotHashesSysvar: Address
+        vote: Vote
+        voteAccount: Account
+        voteAuthority: Account
+    }
+
+    """
+    Vote: AuthorizeChecked instruction
+    """
+    type VoteAuthorizeCheckedInstruction implements TransactionInstruction {
+        programId: Address
+        authority: Account
+        authorityType: String
+        clockSysvar: Address
+        newAuthority: Account
+        voteAccount: Account
+    }
+`
+);
+
+// src/schema/root.ts
+var rootTypeDefs = (
+  /* GraphQL */
+  `
+    type Query {
+        account(
+            address: String!
+            commitment: Commitment
+            dataSlice: DataSlice
+            encoding: AccountEncoding
+            minContextSlot: BigInt
+        ): Account
+        block(
+            slot: BigInt!
+            commitment: Commitment
+            encoding: TransactionEncoding
+            transactionDetails: BlockTransactionDetails
+        ): Block
+        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
+    }
+`
+);
+
 // src/schema/transaction.ts
 var transactionTypeDefs = (
   /* GraphQL */
@@ -2481,39 +2828,47 @@ var transactionTypeDefs = (
         recentBlockhash: String
     }
 
-    # Transaction interface
+    """
+    Transaction interface
+    """
     interface Transaction {
-        blockTime: String
+        blockTime: BigInt
         meta: TransactionMeta
         slot: BigInt
         version: String
     }
 
-    # A transaction with base58 encoded data
+    """
+    A transaction with base58 encoded data
+    """
     type TransactionBase58 implements Transaction {
-        blockTime: String
+        blockTime: BigInt
         data: Base58EncodedBytes
         meta: TransactionMeta
         slot: BigInt
         version: String
     }
 
-    # A transaction with base64 encoded data
+    """
+    A transaction with base64 encoded data
+    """
     type TransactionBase64 implements Transaction {
-        blockTime: String
+        blockTime: BigInt
         data: Base64EncodedBytes
         meta: TransactionMeta
         slot: BigInt
         version: String
     }
 
-    # A transaction with JSON encoded data
+    """
+    A transaction with JSON encoded data
+    """
     type TransactionDataParsed {
         message: TransactionMessage
         signatures: [String]
     }
     type TransactionParsed implements Transaction {
-        blockTime: String
+        blockTime: BigInt
         data: TransactionDataParsed
         meta: TransactionMeta
         slot: BigInt
@@ -2521,115 +2876,37 @@ var transactionTypeDefs = (
     }
 `
 );
-var transactionResolvers = {
-  Transaction: {
-    __resolveType(transaction) {
-      switch (transaction.encoding) {
-        case "base58":
-          return "TransactionBase58";
-        case "base64":
-          return "TransactionBase64";
-        default:
-          return "TransactionParsed";
-      }
-    }
-  }
-};
 
 // 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);
-    },
-    block(_, args, context, info) {
-      return context.loaders.block.load(args, info);
-    },
-    programAccounts(_, args, context, info) {
-      return context.loaders.programAccounts.load(args, info);
-    },
-    transaction(_, args, context, info) {
-      return context.loaders.transaction.load(args, info);
-    }
-  }
-};
-function createSolanaGraphQLSchema() {
-  return makeExecutableSchema({
-    resolvers: {
-      ...accountResolvers,
-      ...blockResolvers,
-      ...commonResolvers,
-      ...inputResolvers,
-      ...instructionResolvers,
-      ...scalarResolvers,
-      ...schemaResolvers,
-      ...transactionResolvers
-    },
-    typeDefs: [
-      accountTypeDefs,
-      blockTypeDefs,
-      commonTypeDefs,
-      inputTypeDefs,
-      instructionTypeDefs,
-      scalarTypeDefs,
-      schemaTypeDefs,
-      transactionTypeDefs
-    ]
-  });
+function createSolanaGraphQLTypeDefs() {
+  return [
+    accountTypeDefs,
+    blockTypeDefs,
+    commonTypeDefs,
+    inputTypeDefs,
+    instructionTypeDefs,
+    rootTypeDefs,
+    scalarTypeDefs,
+    transactionTypeDefs
+  ];
 }
 
-// src/rpc.ts
+// src/index.ts
 function createRpcGraphQL(rpc) {
-  const context = createSolanaGraphQLContext(rpc);
-  const schema = createSolanaGraphQLSchema();
+  const schema = makeExecutableSchema({
+    resolvers: createSolanaGraphQLResolvers(),
+    typeDefs: createSolanaGraphQLTypeDefs()
+  });
   return {
-    context,
     async query(source, variableValues) {
+      const contextValue = createSolanaGraphQLContext(rpc);
       return graphql({
-        contextValue: this.context,
-        schema: this.schema,
+        contextValue,
+        schema,
         source,
         variableValues
       });
-    },
-    schema
+    }
   };
 }