@solana/rpc-graphql 2.0.0-experimental.278784a → 2.0.0-experimental.38794f3

package/dist/index.node.js

@@ -1,4 +1,4 @@
-import { GraphQLSchema, GraphQLObjectType, graphql } from 'graphql';
+import { GraphQLSchema, GraphQLObjectType, graphql, GraphQLList, GraphQLBoolean, GraphQLString, GraphQLNonNull, GraphQLEnumType, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLScalarType, Kind, GraphQLInt, GraphQLUnionType } from 'graphql';
 
 // src/rpc.ts
 
@@ -34,10 +34,2263 @@ function createGraphQLCache() {
 }
 
 // src/context.ts
+async function resolveAccount({ address, encoding = "jsonParsed", ...config }, cache, rpc, info) {
+  if (info && info.fieldNodes[0].selectionSet) {
+    const selectionSet = info.fieldNodes[0].selectionSet;
+    const requestedFields = selectionSet.selections.map((field) => {
+      if (field.kind === "Field") {
+        return field.name.value;
+      }
+      return null;
+    });
+    if (requestedFields && requestedFields.length === 1 && requestedFields[0] === "address") {
+      return { address };
+    }
+  }
+  const requestConfig = { encoding, ...config };
+  const cached = cache.get(address, requestConfig);
+  if (cached !== null) {
+    return cached;
+  }
+  const account = await rpc.getAccountInfo(address, requestConfig).send().then((res) => res.value).catch((e) => {
+    throw e;
+  });
+  if (account === null) {
+    return {
+      address
+    };
+  }
+  const [data, responseEncoding] = Array.isArray(account.data) ? encoding === "jsonParsed" ? [account.data[0], "base64"] : [account.data[0], encoding] : [account.data, "jsonParsed"];
+  const queryResponse = {
+    ...account,
+    address,
+    data,
+    encoding: responseEncoding
+  };
+  cache.insert(address, requestConfig, queryResponse);
+  return queryResponse;
+}
+async function resolveBlock({ slot, encoding = "jsonParsed", ...config }, cache, rpc) {
+  const requestConfig = { encoding, ...config };
+  const cached = cache.get(slot, config);
+  if (cached !== null) {
+    return cached;
+  }
+  const block = await rpc.getBlock(slot, requestConfig).send();
+  if (block === null) {
+    return null;
+  }
+  cache.insert(slot, config, block);
+  return block;
+}
+async function resolveProgramAccounts({ programAddress, encoding = "jsonParsed", ...config }, cache, rpc) {
+  const requestConfig = { encoding, ...config };
+  const cached = cache.get(programAddress, requestConfig);
+  if (cached !== null) {
+    return cached;
+  }
+  const programAccounts = await rpc.getProgramAccounts(programAddress, requestConfig).send().then((res) => {
+    if ("value" in res) {
+      return res.value;
+    }
+    return res;
+  }).catch((e) => {
+    throw e;
+  });
+  const queryResponse = programAccounts.map((programAccount) => {
+    const [data, responseEncoding] = Array.isArray(programAccount.account.data) ? encoding === "jsonParsed" ? [programAccount.account.data[0], "base64"] : [programAccount.account.data[0], encoding] : [programAccount.account.data, "jsonParsed"];
+    const pubkey = programAccount.pubkey;
+    return {
+      ...programAccount.account,
+      address: pubkey,
+      data,
+      encoding: responseEncoding
+    };
+  });
+  cache.insert(programAddress, requestConfig, queryResponse);
+  return queryResponse;
+}
+async function resolveTransaction({ signature, encoding = "jsonParsed", ...config }, cache, rpc) {
+  const requestConfig = { encoding, ...config };
+  const cached = cache.get(signature, requestConfig);
+  if (cached !== null) {
+    return cached;
+  }
+  const transaction = await rpc.getTransaction(signature, requestConfig).send();
+  if (transaction === null) {
+    return null;
+  }
+  const [transactionData, responseEncoding, responseFormat] = Array.isArray(transaction.transaction) ? encoding === "jsonParsed" ? [transaction.transaction[0], "base64", "unparsed"] : [transaction.transaction[0], encoding, "unparsed"] : encoding === "jsonParsed" ? [transaction.transaction, encoding, "parsed"] : [transaction.transaction, encoding, "unparsed"];
+  if (transaction.meta) {
+    transaction.meta["format"] = responseFormat;
+  }
+  if (transactionData.message) {
+    transactionData.message["format"] = responseFormat;
+  }
+  const queryResponse = {
+    ...transaction,
+    encoding: responseEncoding,
+    transaction: transactionData
+  };
+  cache.insert(signature, requestConfig, queryResponse);
+  return queryResponse;
+}
 function createSolanaGraphQLContext(rpc) {
   const cache = createGraphQLCache();
-  return { cache, rpc };
+  return {
+    cache,
+    resolveAccount(args, info) {
+      return resolveAccount(args, this.cache, this.rpc, info);
+    },
+    resolveBlock(args) {
+      return resolveBlock(args, this.cache, this.rpc);
+    },
+    resolveProgramAccounts(args) {
+      return resolveProgramAccounts(args, this.cache, this.rpc);
+    },
+    resolveTransaction(args) {
+      return resolveTransaction(args, this.cache, this.rpc);
+    },
+    rpc
+  };
+}
+var BigIntScalar = () => new GraphQLScalarType({
+  name: "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/picks.ts
+function boolean() {
+  return { type: GraphQLBoolean };
 }
+var memoisedBigint;
+function bigint() {
+  if (!memoisedBigint)
+    memoisedBigint = { type: BigIntScalar() };
+  return memoisedBigint;
+}
+function number() {
+  return { type: GraphQLInt };
+}
+function string() {
+  return { type: GraphQLString };
+}
+function type(fieldType) {
+  return {
+    type: fieldType
+  };
+}
+function nonNull(fieldType) {
+  return {
+    type: new GraphQLNonNull(fieldType.type)
+  };
+}
+function list(elementType) {
+  return {
+    type: new GraphQLList(elementType.type)
+  };
+}
+function object(name, fields) {
+  return {
+    type: new GraphQLObjectType({
+      fields,
+      name
+    })
+  };
+}
+
+// src/schema/inputs.ts
+var memoisedAccountEncodingInputType;
+var accountEncodingInputType = () => {
+  if (!memoisedAccountEncodingInputType)
+    memoisedAccountEncodingInputType = new GraphQLEnumType({
+      name: "AccountEncoding",
+      values: {
+        base58: {
+          value: "base58"
+        },
+        base64: {
+          value: "base64"
+        },
+        base64Zstd: {
+          value: "base64+zstd"
+        },
+        jsonParsed: {
+          value: "jsonParsed"
+        }
+      }
+    });
+  return memoisedAccountEncodingInputType;
+};
+var memoisedBlockTransactionDetailsInputType;
+var blockTransactionDetailsInputType = () => {
+  if (!memoisedBlockTransactionDetailsInputType)
+    memoisedBlockTransactionDetailsInputType = new GraphQLEnumType({
+      name: "BlockTransactionDetails",
+      values: {
+        accounts: {
+          value: "accounts"
+        },
+        full: {
+          value: "full"
+        },
+        none: {
+          value: "none"
+        },
+        signatures: {
+          value: "signatures"
+        }
+      }
+    });
+  return memoisedBlockTransactionDetailsInputType;
+};
+var memoisedCommitmentInputType;
+var commitmentInputType = () => {
+  if (!memoisedCommitmentInputType)
+    memoisedCommitmentInputType = new GraphQLEnumType({
+      name: "Commitment",
+      values: {
+        confirmed: {
+          value: "confirmed"
+        },
+        finalized: {
+          value: "finalized"
+        },
+        processed: {
+          value: "processed"
+        }
+      }
+    });
+  return memoisedCommitmentInputType;
+};
+var memoisedDataSliceInputType;
+var dataSliceInputType = () => {
+  if (!memoisedDataSliceInputType)
+    memoisedDataSliceInputType = new GraphQLInputObjectType({
+      fields: {
+        length: number(),
+        offset: number()
+      },
+      name: "DataSliceConfig"
+    });
+  return memoisedDataSliceInputType;
+};
+var memoisedMaxSupportedTransactionVersionInputType;
+var maxSupportedTransactionVersionInputType = () => {
+  if (!memoisedMaxSupportedTransactionVersionInputType)
+    memoisedMaxSupportedTransactionVersionInputType = new GraphQLEnumType({
+      name: "MaxSupportedTransactionVersion",
+      values: {
+        legacy: {
+          value: "legacy"
+        },
+        zero: {
+          value: "0"
+        }
+      }
+    });
+  return memoisedMaxSupportedTransactionVersionInputType;
+};
+var memoisedProgramAccountFilterInputType;
+var programAccountFilterInputType = () => {
+  if (!memoisedProgramAccountFilterInputType)
+    memoisedProgramAccountFilterInputType = new GraphQLInputObjectType({
+      fields: {
+        bytes: bigint(),
+        dataSize: bigint(),
+        encoding: string(),
+        offset: bigint()
+      },
+      name: "ProgramAccountFilter"
+    });
+  return memoisedProgramAccountFilterInputType;
+};
+var memoisedTransactionEncodingInputType;
+var transactionEncodingInputType = () => {
+  if (!memoisedTransactionEncodingInputType)
+    memoisedTransactionEncodingInputType = new GraphQLEnumType({
+      name: "TransactionEncoding",
+      values: {
+        base58: {
+          value: "base58"
+        },
+        base64: {
+          value: "base64"
+        },
+        json: {
+          value: "json"
+        },
+        jsonParsed: {
+          value: "jsonParsed"
+        }
+      }
+    });
+  return memoisedTransactionEncodingInputType;
+};
+var memoisedTokenAmountType;
+var tokenAmountType = () => {
+  if (!memoisedTokenAmountType) {
+    memoisedTokenAmountType = new GraphQLObjectType({
+      fields: {
+        amount: string(),
+        decimals: number(),
+        uiAmount: bigint(),
+        uiAmountString: string()
+      },
+      name: "TokenAmount"
+    });
+  }
+  return memoisedTokenAmountType;
+};
+var memoisedAccountInterfaceFields;
+var accountInterfaceFields = () => {
+  if (!memoisedAccountInterfaceFields) {
+    memoisedAccountInterfaceFields = {
+      address: string(),
+      encoding: string(),
+      executable: boolean(),
+      lamports: bigint(),
+      rentEpoch: bigint()
+    };
+  }
+  return memoisedAccountInterfaceFields;
+};
+var memoisedAccountInterface;
+var accountInterface = () => {
+  if (!memoisedAccountInterface) {
+    memoisedAccountInterface = new GraphQLInterfaceType({
+      description: "A Solana account",
+      fields: () => ({
+        ...accountInterfaceFields(),
+        owner: type(accountInterface())
+      }),
+      name: "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.data.parsed.type === "mint" && account.data.program === "spl-token") {
+            return "MintAccount";
+          }
+          if (account.data.parsed.type === "account" && account.data.program === "spl-token") {
+            return "TokenAccount";
+          }
+          if (account.data.program === "nonce") {
+            return "NonceAccount";
+          }
+          if (account.data.program === "stake") {
+            return "StakeAccount";
+          }
+          if (account.data.parsed.type === "vote" && account.data.program === "vote") {
+            return "VoteAccount";
+          }
+          if (account.data.parsed.type === "lookupTable" && account.data.program === "address-lookup-table") {
+            return "LookupTableAccount";
+          }
+        }
+        return "AccountBase64";
+      }
+    });
+  }
+  return memoisedAccountInterface;
+};
+var accountType = (name, description, data) => new GraphQLObjectType({
+  description,
+  fields: {
+    ...accountInterfaceFields(),
+    data,
+    // Nested Account interface
+    owner: {
+      args: {
+        commitment: type(commitmentInputType()),
+        dataSlice: type(dataSliceInputType()),
+        encoding: type(accountEncodingInputType()),
+        minContextSlot: bigint()
+      },
+      resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+      type: accountInterface()
+    }
+  },
+  interfaces: [accountInterface()],
+  name
+});
+var accountDataJsonParsed = (name, parsedInfoFields) => object(name + "Data", {
+  parsed: object(name + "DataParsed", {
+    info: object(name + "DataParsedInfo", parsedInfoFields),
+    type: string()
+  }),
+  program: string(),
+  space: bigint()
+});
+var memoisedAccountBase58;
+var accountBase58 = () => {
+  if (!memoisedAccountBase58)
+    memoisedAccountBase58 = accountType("AccountBase58", "A Solana account with base58 encoded data", string());
+  return memoisedAccountBase58;
+};
+var memoisedAccountBase64;
+var accountBase64 = () => {
+  if (!memoisedAccountBase64)
+    memoisedAccountBase64 = accountType("AccountBase64", "A Solana account with base64 encoded data", string());
+  return memoisedAccountBase64;
+};
+var memoisedAccountBase64Zstd;
+var accountBase64Zstd = () => {
+  if (!memoisedAccountBase64Zstd)
+    memoisedAccountBase64Zstd = accountType(
+      "AccountBase64Zstd",
+      "A Solana account with base64 encoded data compressed with zstd",
+      string()
+    );
+  return memoisedAccountBase64Zstd;
+};
+var memoisedAccountNonceAccount;
+var accountNonceAccount = () => {
+  if (!memoisedAccountNonceAccount)
+    memoisedAccountNonceAccount = accountType(
+      "NonceAccount",
+      "A nonce account",
+      accountDataJsonParsed("Nonce", {
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        blockhash: string(),
+        feeCalculator: object("NonceFeeCalculator", {
+          lamportsPerSignature: string()
+        })
+      })
+    );
+  return memoisedAccountNonceAccount;
+};
+var memoisedAccountLookupTable;
+var accountLookupTable = () => {
+  if (!memoisedAccountLookupTable)
+    memoisedAccountLookupTable = accountType(
+      "LookupTableAccount",
+      "An address lookup table account",
+      accountDataJsonParsed("LookupTable", {
+        addresses: list(string()),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        deactivationSlot: string(),
+        lastExtendedSlot: string(),
+        lastExtendedSlotStartIndex: number()
+      })
+    );
+  return memoisedAccountLookupTable;
+};
+var memoisedAccountMint;
+var accountMint = () => {
+  if (!memoisedAccountMint)
+    memoisedAccountMint = accountType(
+      "MintAccount",
+      "An SPL mint",
+      accountDataJsonParsed("Mint", {
+        decimals: number(),
+        freezeAuthority: string(),
+        isInitialized: boolean(),
+        // Nested Account interface
+        mintAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mintAuthority }, info),
+          type: accountInterface()
+        },
+        supply: string()
+      })
+    );
+  return memoisedAccountMint;
+};
+var memoisedAccountTokenAccount;
+var accountTokenAccount = () => {
+  if (!memoisedAccountTokenAccount)
+    memoisedAccountTokenAccount = accountType(
+      "TokenAccount",
+      "An SPL token account",
+      accountDataJsonParsed("TokenAccount", {
+        isNative: boolean(),
+        mint: string(),
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
+        state: string(),
+        tokenAmount: type(tokenAmountType())
+      })
+    );
+  return memoisedAccountTokenAccount;
+};
+var memoisedAccountStakeAccount;
+var accountStakeAccount = () => {
+  if (!memoisedAccountStakeAccount)
+    memoisedAccountStakeAccount = accountType(
+      "StakeAccount",
+      "A stake account",
+      accountDataJsonParsed("Stake", {
+        meta: object("StakeMeta", {
+          authorized: object("StakeMetaAuthorized", {
+            // Nested Account interface
+            staker: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.staker }, info),
+              type: accountInterface()
+            },
+            // Nested Account interface
+            withdrawer: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.withdrawer }, info),
+              type: accountInterface()
+            }
+          }),
+          lockup: object("StakeMetaLockup", {
+            // Nested Account interface
+            custodian: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+              type: accountInterface()
+            },
+            epoch: bigint(),
+            unixTimestamp: bigint()
+          }),
+          rentExemptReserve: string()
+        }),
+        stake: object("StakeStake", {
+          creditsObserved: bigint(),
+          delegation: object("StakeStakeDelegation", {
+            activationEpoch: bigint(),
+            deactivationEpoch: bigint(),
+            stake: string(),
+            // Nested Account interface
+            voter: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voter }, info),
+              type: accountInterface()
+            },
+            warmupCooldownRate: number()
+          })
+        })
+      })
+    );
+  return memoisedAccountStakeAccount;
+};
+var memoisedAccountVoteAccount;
+var accountVoteAccount = () => {
+  if (!memoisedAccountVoteAccount)
+    memoisedAccountVoteAccount = accountType(
+      "VoteAccount",
+      "A vote account",
+      accountDataJsonParsed("Vote", {
+        authorizedVoters: list(
+          object("VoteAuthorizedVoter", {
+            // Nested Account interface
+            authorizedVoter: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorizedVoter }, info),
+              type: accountInterface()
+            },
+            epoch: bigint()
+          })
+        ),
+        // Nested Account interface
+        authorizedWithdrawer: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorizedWithdrawer }, info),
+          type: accountInterface()
+        },
+        commission: number(),
+        epochCredits: list(
+          object("VoteEpochCredits", {
+            credits: string(),
+            epoch: bigint(),
+            previousCredits: string()
+          })
+        ),
+        lastTimestamp: object("VoteLastTimestamp", {
+          slot: bigint(),
+          timestamp: bigint()
+        }),
+        // Nested Account interface
+        node: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nodePubkey }, info),
+          type: accountInterface()
+        },
+        priorVoters: list(string()),
+        rootSlot: bigint(),
+        votes: list(
+          object("VoteVote", {
+            confirmationCount: number(),
+            slot: bigint()
+          })
+        )
+      })
+    );
+  return memoisedAccountVoteAccount;
+};
+var memoisedAccountTypes;
+var accountTypes = () => {
+  if (!memoisedAccountTypes)
+    memoisedAccountTypes = [
+      accountBase58(),
+      accountBase64(),
+      accountBase64Zstd(),
+      accountNonceAccount(),
+      accountLookupTable(),
+      accountMint(),
+      accountTokenAccount(),
+      accountStakeAccount(),
+      accountVoteAccount()
+    ];
+  return memoisedAccountTypes;
+};
+
+// src/schema/account/query.ts
+var accountQuery = () => ({
+  account: {
+    args: {
+      address: nonNull(string()),
+      commitment: type(commitmentInputType()),
+      dataSlice: type(dataSliceInputType()),
+      encoding: type(accountEncodingInputType()),
+      minContextSlot: bigint()
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resolve: (_parent, args, context, info) => context.resolveAccount(args, info),
+    type: accountInterface()
+  }
+});
+var memoisedTokenBalance;
+var tokenBalance = () => {
+  if (!memoisedTokenBalance)
+    memoisedTokenBalance = new GraphQLObjectType({
+      fields: {
+        accountIndex: number(),
+        mint: string(),
+        owner: string(),
+        programId: string(),
+        uiAmountString: string()
+      },
+      name: "TokenBalance"
+    });
+  return memoisedTokenBalance;
+};
+var memoisedTransactionStatus;
+var transactionStatus = () => {
+  if (!memoisedTransactionStatus)
+    memoisedTransactionStatus = new GraphQLUnionType({
+      name: "TransactionStatus",
+      types: [
+        new GraphQLObjectType({
+          fields: {
+            Err: string()
+          },
+          name: "TransactionStatusError"
+        }),
+        new GraphQLObjectType({
+          fields: {
+            Ok: string()
+          },
+          name: "TransactionStatusOk"
+        })
+      ]
+    });
+  return memoisedTransactionStatus;
+};
+var memoisedReward;
+var reward = () => {
+  if (!memoisedReward)
+    memoisedReward = new GraphQLObjectType({
+      fields: {
+        commission: number(),
+        lamports: bigint(),
+        postBalance: bigint(),
+        pubkey: string(),
+        rewardType: string()
+      },
+      name: "Reward"
+    });
+  return memoisedReward;
+};
+var memoisedAddressTableLookup;
+var addressTableLookup = () => {
+  if (!memoisedAddressTableLookup)
+    memoisedAddressTableLookup = new GraphQLObjectType({
+      fields: {
+        accountKey: string(),
+        readableIndexes: list(number()),
+        writableIndexes: list(number())
+      },
+      name: "AddressTableLookup"
+    });
+  return memoisedAddressTableLookup;
+};
+var memoisedReturnData;
+var returnData = () => {
+  if (!memoisedReturnData)
+    memoisedReturnData = new GraphQLObjectType({
+      fields: {
+        data: string(),
+        programId: string()
+      },
+      name: "ReturnData"
+    });
+  return memoisedReturnData;
+};
+var memoisedTransactionInstruction;
+var transactionInstruction = () => {
+  if (!memoisedTransactionInstruction)
+    memoisedTransactionInstruction = new GraphQLObjectType({
+      fields: {
+        accounts: list(number()),
+        data: string(),
+        programIdIndex: number()
+      },
+      name: "TransactionInstruction"
+    });
+  return memoisedTransactionInstruction;
+};
+var memoisedTransactionMetaLoadedAddresses;
+var transactionMetaLoadedAddresses = () => {
+  if (!memoisedTransactionMetaLoadedAddresses)
+    memoisedTransactionMetaLoadedAddresses = new GraphQLObjectType({
+      fields: {
+        readonly: list(string()),
+        // Base58 encoded addresses
+        writable: list(string())
+        // Base58 encoded addresses
+      },
+      name: "TransactionMetaLoadedAddresses"
+    });
+  return memoisedTransactionMetaLoadedAddresses;
+};
+var memoisedParsedTransactionInstructionInterface;
+var parsedTransactionInstructionInterface = () => {
+  if (!memoisedParsedTransactionInstructionInterface)
+    memoisedParsedTransactionInstructionInterface = new GraphQLInterfaceType({
+      fields: {
+        programId: string()
+      },
+      name: "ParsedTransactionInstruction",
+      resolveType(instruction) {
+        if (instruction.program === "address-lookup-table") {
+          if (instruction.info.type === "createLookupTable") {
+            return "CreateLookupTableInstruction";
+          }
+          if (instruction.info.type === "freezeLookupTable") {
+            return "FreezeLookupTableInstruction";
+          }
+          if (instruction.info.type === "extendLookupTable") {
+            return "ExtendLookupTableInstruction";
+          }
+          if (instruction.info.type === "deactivateLookupTable") {
+            return "DeactivateLookupTableInstruction";
+          }
+          if (instruction.info.type === "closeLookupTable") {
+            return "CloseLookupTableInstruction";
+          }
+        }
+        if (instruction.program === "bpf-loader") {
+          if (instruction.info.type === "write") {
+            return "BpfLoaderWriteInstruction";
+          }
+          if (instruction.info.type === "finalize") {
+            return "BpfLoaderFinalizeInstruction";
+          }
+        }
+        if (instruction.program === "bpf-upgradeable-loader") {
+          if (instruction.info.type === "initializeBuffer") {
+            return "BpfUpgradeableLoaderInitializeBufferInstruction";
+          }
+          if (instruction.info.type === "write") {
+            return "BpfUpgradeableLoaderWriteInstruction";
+          }
+          if (instruction.info.type === "deployWithMaxDataLen") {
+            return "BpfUpgradeableLoaderDeployWithMaxDataLenInstruction";
+          }
+          if (instruction.info.type === "upgrade") {
+            return "BpfUpgradeableLoaderUpgradeInstruction";
+          }
+          if (instruction.info.type === "setAuthority") {
+            return "BpfUpgradeableLoaderSetAuthorityInstruction";
+          }
+          if (instruction.info.type === "setAuthorityChecked") {
+            return "BpfUpgradeableLoaderSetAuthorityCheckedInstruction";
+          }
+          if (instruction.info.type === "close") {
+            return "BpfUpgradeableLoaderCloseInstruction";
+          }
+          if (instruction.info.type === "extendProgram") {
+            return "BpfUpgradeableLoaderExtendProgramInstruction";
+          }
+        }
+        if (instruction.program === "spl-associated-token-account") {
+          if (instruction.info.type === "create") {
+            return "SplAssociatedTokenCreateInstruction";
+          }
+          if (instruction.info.type === "createIdempotent") {
+            return "SplAssociatedTokenCreateIdempotentInstruction";
+          }
+          if (instruction.info.type === "recoverNested") {
+            return "SplAssociatedTokenRecoverNestedInstruction";
+          }
+        }
+        if (instruction.program === "spl-memo") {
+          return "SplMemoInstruction";
+        }
+        if (instruction.program === "spl-token") {
+          if (instruction.info.type === "initializeMint") {
+            return "SplTokenInitializeMintInstruction";
+          }
+          if (instruction.info.type === "initializeMint2") {
+            return "SplTokenInitializeMint2Instruction";
+          }
+          if (instruction.info.type === "initializeAccount") {
+            return "SplTokenInitializeAccountInstruction";
+          }
+          if (instruction.info.type === "initializeAccount2") {
+            return "SplTokenInitializeAccount2Instruction";
+          }
+          if (instruction.info.type === "initializeAccount3") {
+            return "SplTokenInitializeAccount3Instruction";
+          }
+          if (instruction.info.type === "initializeMultisig") {
+            return "SplTokenInitializeMultisigInstruction";
+          }
+          if (instruction.info.type === "initializeMultisig2") {
+            return "SplTokenInitializeMultisig2Instruction";
+          }
+          if (instruction.info.type === "transfer") {
+            return "SplTokenTransferInstruction";
+          }
+          if (instruction.info.type === "approve") {
+            return "SplTokenApproveInstruction";
+          }
+          if (instruction.info.type === "revoke") {
+            return "SplTokenRevokeInstruction";
+          }
+          if (instruction.info.type === "setAuthority") {
+            return "SplTokenSetAuthorityInstruction";
+          }
+          if (instruction.info.type === "mintTo") {
+            return "SplTokenMintToInstruction";
+          }
+          if (instruction.info.type === "burn") {
+            return "SplTokenBurnInstruction";
+          }
+          if (instruction.info.type === "closeAccount") {
+            return "SplTokenCloseAccountInstruction";
+          }
+          if (instruction.info.type === "freezeAccount") {
+            return "SplTokenFreezeAccountInstruction";
+          }
+          if (instruction.info.type === "thawAccount") {
+            return "SplTokenThawAccountInstruction";
+          }
+          if (instruction.info.type === "transferChecked") {
+            return "SplTokenTransferCheckedInstruction";
+          }
+          if (instruction.info.type === "approveChecked") {
+            return "SplTokenApproveCheckedInstruction";
+          }
+          if (instruction.info.type === "mintToChecked") {
+            return "SplTokenMintToCheckedInstruction";
+          }
+          if (instruction.info.type === "burnChecked") {
+            return "SplTokenBurnCheckedInstruction";
+          }
+          if (instruction.info.type === "syncNative") {
+            return "SplTokenSyncNativeInstruction";
+          }
+          if (instruction.info.type === "getAccountDataSize") {
+            return "SplTokenGetAccountDataSizeInstruction";
+          }
+          if (instruction.info.type === "initializeImmutableOwner") {
+            return "SplTokenInitializeImmutableOwnerInstruction";
+          }
+          if (instruction.info.type === "amountToUiAmount") {
+            return "SplTokenAmountToUiAmountInstruction";
+          }
+          if (instruction.info.type === "uiAmountToAmount") {
+            return "SplTokenUiAmountToAmountInstruction";
+          }
+          if (instruction.info.type === "initializeMintCloseAuthority") {
+            return "SplTokenInitializeMintCloseAuthorityInstruction";
+          }
+        }
+        if (instruction.program === "stake") {
+          if (instruction.info.type === "initialize") {
+            return "StakeInitializeInstruction";
+          }
+          if (instruction.info.type === "authorize") {
+            return "StakeAuthorizeInstruction";
+          }
+          if (instruction.info.type === "delegate") {
+            return "StakeDelegateStakeInstruction";
+          }
+          if (instruction.info.type === "split") {
+            return "StakeSplitInstruction";
+          }
+          if (instruction.info.type === "withdraw") {
+            return "StakeWithdrawInstruction";
+          }
+          if (instruction.info.type === "deactivate") {
+            return "StakeDeactivateInstruction";
+          }
+          if (instruction.info.type === "setLockup") {
+            return "StakeSetLockupInstruction";
+          }
+          if (instruction.info.type === "merge") {
+            return "StakeMergeInstruction";
+          }
+          if (instruction.info.type === "authorizeWithSeed") {
+            return "StakeAuthorizeWithSeedInstruction";
+          }
+          if (instruction.info.type === "initializeChecked") {
+            return "StakeInitializeCheckedInstruction";
+          }
+          if (instruction.info.type === "authorizeChecked") {
+            return "StakeAuthorizeCheckedInstruction";
+          }
+          if (instruction.info.type === "authorizeCheckedWithSeed") {
+            return "StakeAuthorizeCheckedWithSeedInstruction";
+          }
+          if (instruction.info.type === "setLockupChecked") {
+            return "StakeSetLockupCheckedInstruction";
+          }
+          if (instruction.info.type === "deactivateDelinquent") {
+            return "StakeDeactivateDelinquentInstruction";
+          }
+          if (instruction.info.type === "redelegate") {
+            return "StakeRedelegateInstruction";
+          }
+        }
+        if (instruction.program === "system") {
+          if (instruction.info.type === "createAccount") {
+            return "CreateAccountInstruction";
+          }
+          if (instruction.info.type === "assign") {
+            return "AssignInstruction";
+          }
+          if (instruction.info.type === "transfer") {
+            return "TransferInstruction";
+          }
+          if (instruction.info.type === "createAccountWithSeed") {
+            return "CreateAccountWithSeedInstruction";
+          }
+          if (instruction.info.type === "advanceNonceAccount") {
+            return "AdvanceNonceAccountInstruction";
+          }
+          if (instruction.info.type === "withdrawNonceAccount") {
+            return "WithdrawNonceAccountInstruction";
+          }
+          if (instruction.info.type === "initializeNonceAccount") {
+            return "InitializeNonceAccountInstruction";
+          }
+          if (instruction.info.type === "authorizeNonceAccount") {
+            return "AuthorizeNonceAccountInstruction";
+          }
+          if (instruction.info.type === "upgradeNonceAccount") {
+            return "UpgradeNonceAccountInstruction";
+          }
+          if (instruction.info.type === "allocate") {
+            return "AllocateInstruction";
+          }
+          if (instruction.info.type === "allocateWithSeed") {
+            return "AllocateWithSeedInstruction";
+          }
+          if (instruction.info.type === "assignWithSeed") {
+            return "AssignWithSeedInstruction";
+          }
+          if (instruction.info.type === "transferWithSeed") {
+            return "TransferWithSeedInstruction";
+          }
+        }
+        if (instruction.program === "vote") {
+          if (instruction.info.type === "initialize") {
+            return "VoteInitializeAccountInstruction";
+          }
+          if (instruction.info.type === "authorize") {
+            return "VoteAuthorizeInstruction";
+          }
+          if (instruction.info.type === "authorizeWithSeed") {
+            return "VoteAuthorizeWithSeedInstruction";
+          }
+          if (instruction.info.type === "authorizeCheckedWithSeed") {
+            return "VoteAuthorizeCheckedWithSeedInstruction";
+          }
+          if (instruction.info.type === "vote") {
+            return "VoteVoteInstruction";
+          }
+          if (instruction.info.type === "updatevotestate") {
+            return "VoteUpdateVoteStateInstruction";
+          }
+          if (instruction.info.type === "updatevotestateswitch") {
+            return "VoteUpdateVoteStateSwitchInstruction";
+          }
+          if (instruction.info.type === "compactupdatevotestate") {
+            return "VoteCompactUpdateVoteStateInstruction";
+          }
+          if (instruction.info.type === "compactupdatevotestateswitch") {
+            return "VoteCompactUpdateVoteStateSwitchInstruction";
+          }
+          if (instruction.info.type === "withdraw") {
+            return "VoteWithdrawInstruction";
+          }
+          if (instruction.info.type === "updateValidatorIdentity") {
+            return "VoteUpdateValidatorIdentityInstruction";
+          }
+          if (instruction.info.type === "updateCommission") {
+            return "VoteUpdateCommissionInstruction";
+          }
+          if (instruction.info.type === "voteSwitch") {
+            return "VoteVoteSwitchInstruction";
+          }
+          if (instruction.info.type === "authorizeChecked") {
+            return "VoteAuthorizeCheckedInstruction";
+          }
+        }
+        return "PartiallyDecodedInstruction";
+      }
+    });
+  return memoisedParsedTransactionInstructionInterface;
+};
+var parsedTransactionInstructionType = (name, parsedInfoFields) => new GraphQLObjectType({
+  fields: {
+    parsed: object(name + "Parsed", {
+      info: object(name + "ParsedInfo", parsedInfoFields),
+      type: string()
+    }),
+    program: string(),
+    programId: string()
+  },
+  interfaces: [parsedTransactionInstructionInterface()],
+  name
+});
+var memoisedPartiallyDecodedTransactionInstruction;
+var partiallyDecodedTransactionInstruction = () => {
+  if (!memoisedPartiallyDecodedTransactionInstruction)
+    memoisedPartiallyDecodedTransactionInstruction = new GraphQLObjectType({
+      fields: {
+        accounts: list(string()),
+        data: string(),
+        programId: string()
+      },
+      interfaces: [parsedTransactionInstructionInterface()],
+      name: "PartiallyDecodedInstruction"
+    });
+  return memoisedPartiallyDecodedTransactionInstruction;
+};
+var memoisedParsedInstructionsAddressLookupTable;
+var parsedInstructionsAddressLookupTable = () => {
+  if (!memoisedParsedInstructionsAddressLookupTable)
+    memoisedParsedInstructionsAddressLookupTable = [
+      parsedTransactionInstructionType("CreateLookupTableInstruction", {
+        bumpSeed: number(),
+        lookupTableAccount: string(),
+        lookupTableAuthority: string(),
+        payerAccount: string(),
+        recentSlot: bigint(),
+        systemProgram: string()
+      }),
+      parsedTransactionInstructionType("FreezeLookupTableInstruction", {
+        lookupTableAccount: string(),
+        lookupTableAuthority: string()
+      }),
+      parsedTransactionInstructionType("ExtendLookupTableInstruction", {
+        lookupTableAccount: string(),
+        lookupTableAuthority: string(),
+        newAddresses: list(string()),
+        payerAccount: string(),
+        systemProgram: string()
+      }),
+      parsedTransactionInstructionType("DeactivateLookupTableInstruction", {
+        lookupTableAccount: string(),
+        lookupTableAuthority: string()
+      }),
+      parsedTransactionInstructionType("CloseLookupTableInstruction", {
+        lookupTableAccount: string(),
+        lookupTableAuthority: string(),
+        recipient: string()
+      })
+    ];
+  return memoisedParsedInstructionsAddressLookupTable;
+};
+var memoisedParsedInstructionsBpfLoader;
+var parsedInstructionsBpfLoader = () => {
+  if (!memoisedParsedInstructionsBpfLoader)
+    memoisedParsedInstructionsBpfLoader = [
+      parsedTransactionInstructionType("BpfLoaderWriteInstruction", {
+        account: string(),
+        bytes: string(),
+        offset: number()
+      }),
+      parsedTransactionInstructionType("BpfLoaderFinalizeInstruction", {
+        account: string()
+      })
+    ];
+  return memoisedParsedInstructionsBpfLoader;
+};
+var memoisedParsedInstructionsBpfUpgradeableLoader;
+var parsedInstructionsBpfUpgradeableLoader = () => {
+  if (!memoisedParsedInstructionsBpfUpgradeableLoader)
+    memoisedParsedInstructionsBpfUpgradeableLoader = [
+      parsedTransactionInstructionType("BpfUpgradeableLoaderInitializeBufferInstruction", {
+        account: string()
+      }),
+      parsedTransactionInstructionType("BpfUpgradeableLoaderWriteInstruction", {
+        account: string(),
+        authority: string(),
+        bytes: string(),
+        offset: number()
+      }),
+      parsedTransactionInstructionType("BpfUpgradeableLoaderDeployWithMaxDataLenInstruction", {
+        authority: string(),
+        bufferAccount: string(),
+        clockSysvar: string(),
+        maxDataLen: bigint(),
+        payerAccount: string(),
+        programAccount: string(),
+        programDataAccount: string(),
+        rentSysvar: string()
+      }),
+      parsedTransactionInstructionType("BpfUpgradeableLoaderUpgradeInstruction", {
+        authority: string(),
+        bufferAccount: string(),
+        clockSysvar: string(),
+        programAccount: string(),
+        programDataAccount: string(),
+        rentSysvar: string(),
+        spillAccount: string()
+      }),
+      parsedTransactionInstructionType("BpfUpgradeableLoaderSetAuthorityInstruction", {
+        account: string(),
+        authority: string(),
+        newAuthority: string()
+      }),
+      parsedTransactionInstructionType("BpfUpgradeableLoaderSetAuthorityCheckedInstruction", {
+        account: string(),
+        authority: string(),
+        newAuthority: string()
+      }),
+      parsedTransactionInstructionType("BpfUpgradeableLoaderCloseInstruction", {
+        account: string(),
+        authority: string(),
+        programAccount: string(),
+        recipient: string()
+      }),
+      parsedTransactionInstructionType("BpfUpgradeableLoaderExtendProgramInstruction", {
+        additionalBytes: bigint(),
+        payerAccount: string(),
+        programAccount: string(),
+        programDataAccount: string(),
+        systemProgram: string()
+      })
+    ];
+  return memoisedParsedInstructionsBpfUpgradeableLoader;
+};
+var memoisedParsedInstructionsSplAssociatedToken;
+var parsedInstructionsSplAssociatedToken = () => {
+  if (!memoisedParsedInstructionsSplAssociatedToken)
+    memoisedParsedInstructionsSplAssociatedToken = [
+      parsedTransactionInstructionType("SplAssociatedTokenCreateInstruction", {
+        account: string(),
+        mint: string(),
+        source: string(),
+        systemProgram: string(),
+        tokenProgram: string(),
+        wallet: string()
+      }),
+      parsedTransactionInstructionType("SplAssociatedTokenCreateIdempotentInstruction", {
+        account: string(),
+        mint: string(),
+        source: string(),
+        systemProgram: string(),
+        tokenProgram: string(),
+        wallet: string()
+      }),
+      parsedTransactionInstructionType("SplAssociatedTokenRecoverNestedInstruction", {
+        destination: string(),
+        nestedMint: string(),
+        nestedOwner: string(),
+        nestedSource: string(),
+        ownerMint: string(),
+        tokenProgram: string(),
+        wallet: string()
+      })
+    ];
+  return memoisedParsedInstructionsSplAssociatedToken;
+};
+var memoisedParsedInstructionSplMemo;
+var parsedInstructionSplMemo = () => {
+  if (!memoisedParsedInstructionSplMemo)
+    memoisedParsedInstructionSplMemo = new GraphQLObjectType({
+      fields: {
+        parsed: string(),
+        program: string(),
+        programId: string()
+      },
+      interfaces: [parsedTransactionInstructionInterface()],
+      name: "SplMemoInstruction"
+    });
+  return memoisedParsedInstructionSplMemo;
+};
+var memoisedParsedInstructionsSplToken;
+var parsedInstructionsSplToken = () => {
+  if (!memoisedParsedInstructionsSplToken)
+    memoisedParsedInstructionsSplToken = [
+      parsedTransactionInstructionType("SplTokenInitializeMintInstruction", {
+        decimals: number(),
+        freezeAuthority: string(),
+        mint: string(),
+        mintAuthority: string(),
+        rentSysvar: string()
+      }),
+      parsedTransactionInstructionType("SplTokenInitializeMint2Instruction", {
+        decimals: number(),
+        freezeAuthority: string(),
+        mint: string(),
+        mintAuthority: string()
+      }),
+      parsedTransactionInstructionType("SplTokenInitializeAccountInstruction", {
+        account: string(),
+        mint: string(),
+        owner: string(),
+        rentSysvar: string()
+      }),
+      parsedTransactionInstructionType("SplTokenInitializeAccount2Instruction", {
+        account: string(),
+        mint: string(),
+        owner: string(),
+        rentSysvar: string()
+      }),
+      parsedTransactionInstructionType("SplTokenInitializeAccount3Instruction", {
+        account: string(),
+        mint: string(),
+        owner: string()
+      }),
+      parsedTransactionInstructionType("SplTokenInitializeMultisigInstruction", {
+        m: number(),
+        multisig: string(),
+        rentSysvar: string(),
+        signers: list(string())
+      }),
+      parsedTransactionInstructionType("SplTokenInitializeMultisig2Instruction", {
+        m: number(),
+        multisig: string(),
+        signers: list(string())
+      }),
+      parsedTransactionInstructionType("SplTokenTransferInstruction", {
+        amount: string(),
+        authority: string(),
+        destination: string(),
+        multisigAuthority: string(),
+        source: string()
+      }),
+      parsedTransactionInstructionType("SplTokenApproveInstruction", {
+        amount: string(),
+        delegate: string(),
+        multisigOwner: string(),
+        owner: string(),
+        source: string()
+      }),
+      parsedTransactionInstructionType("SplTokenRevokeInstruction", {
+        multisigOwner: string(),
+        owner: string(),
+        source: string()
+      }),
+      parsedTransactionInstructionType("SplTokenSetAuthorityInstruction", {
+        authority: string(),
+        authorityType: string(),
+        multisigAuthority: string(),
+        newAuthority: string()
+      }),
+      parsedTransactionInstructionType("SplTokenMintToInstruction", {
+        account: string(),
+        amount: string(),
+        authority: string(),
+        mint: string(),
+        mintAuthority: string(),
+        multisigMintAuthority: string()
+      }),
+      parsedTransactionInstructionType("SplTokenBurnInstruction", {
+        account: string(),
+        amount: string(),
+        authority: string(),
+        mint: string(),
+        multisigAuthority: string()
+      }),
+      parsedTransactionInstructionType("SplTokenCloseAccountInstruction", {
+        account: string(),
+        destination: string(),
+        multisigOwner: string(),
+        owner: string()
+      }),
+      parsedTransactionInstructionType("SplTokenFreezeAccountInstruction", {
+        account: string(),
+        freezeAuthority: string(),
+        mint: string(),
+        multisigFreezeAuthority: string()
+      }),
+      parsedTransactionInstructionType("SplTokenThawAccountInstruction", {
+        account: string(),
+        freezeAuthority: string(),
+        mint: string(),
+        multisigFreezeAuthority: string()
+      }),
+      parsedTransactionInstructionType("SplTokenTransferCheckedInstruction", {
+        authority: string(),
+        destination: string(),
+        mint: string(),
+        multisigAuthority: string(),
+        source: string(),
+        tokenAmount: string()
+      }),
+      parsedTransactionInstructionType("SplTokenApproveCheckedInstruction", {
+        delegate: string(),
+        mint: string(),
+        multisigOwner: string(),
+        owner: string(),
+        source: string(),
+        tokenAmount: string()
+      }),
+      parsedTransactionInstructionType("SplTokenMintToCheckedInstruction", {
+        account: string(),
+        authority: string(),
+        mint: string(),
+        mintAuthority: string(),
+        multisigMintAuthority: string(),
+        tokenAmount: string()
+      }),
+      parsedTransactionInstructionType("SplTokenBurnCheckedInstruction", {
+        account: string(),
+        authority: string(),
+        mint: string(),
+        multisigAuthority: string(),
+        tokenAmount: string()
+      }),
+      parsedTransactionInstructionType("SplTokenSyncNativeInstruction", {
+        account: string()
+      }),
+      parsedTransactionInstructionType("SplTokenGetAccountDataSizeInstruction", {
+        extensionTypes: list(string()),
+        mint: string()
+      }),
+      parsedTransactionInstructionType("SplTokenInitializeImmutableOwnerInstruction", {
+        account: string()
+      }),
+      parsedTransactionInstructionType("SplTokenAmountToUiAmountInstruction", {
+        amount: string(),
+        mint: string()
+      }),
+      parsedTransactionInstructionType("SplTokenUiAmountToAmountInstruction", {
+        mint: string(),
+        uiAmount: string()
+      }),
+      parsedTransactionInstructionType("SplTokenInitializeMintCloseAuthorityInstruction", {
+        mint: string(),
+        newAuthority: string()
+      })
+      // TODO: Extensions!
+      // - TransferFeeExtension
+      // - ConfidentialTransferFeeExtension
+      // - DefaultAccountStateExtension
+      // - Reallocate
+      // - MemoTransferExtension
+      // - CreateNativeMint
+      // - InitializeNonTransferableMint
+      // - InterestBearingMintExtension
+      // - CpiGuardExtension
+      // - InitializePermanentDelegate
+      // - TransferHookExtension
+      // - ConfidentialTransferFeeExtension
+      // - WithdrawExcessLamports
+      // - MetadataPointerExtension
+    ];
+  return memoisedParsedInstructionsSplToken;
+};
+var memoisedLockup;
+var lockup = () => {
+  if (!memoisedLockup)
+    memoisedLockup = new GraphQLObjectType({
+      fields: {
+        custodian: string(),
+        epoch: bigint(),
+        unixTimestamp: bigint()
+      },
+      name: "Lockup"
+    });
+  return memoisedLockup;
+};
+var memoisedParsedInstructionsStake;
+var parsedInstructionsStake = () => {
+  if (!memoisedParsedInstructionsStake)
+    memoisedParsedInstructionsStake = [
+      parsedTransactionInstructionType("StakeInitializeInstruction", {
+        authorized: object("StakeInitializeInstructionAuthorized", {
+          staker: string(),
+          withdrawer: string()
+        }),
+        lockup: object("StakeInitializeInstructionLockup", {
+          custodian: string(),
+          epoch: bigint(),
+          unixTimestamp: bigint()
+        }),
+        rentSysvar: string(),
+        stakeAccount: string()
+      }),
+      parsedTransactionInstructionType("StakeAuthorizeInstruction", {
+        authority: string(),
+        authorityType: string(),
+        clockSysvar: string(),
+        custodian: string(),
+        newAuthority: string(),
+        stakeAccount: string()
+      }),
+      parsedTransactionInstructionType("StakeDelegateStakeInstruction", {
+        clockSysvar: string(),
+        stakeAccount: string(),
+        stakeAuthority: string(),
+        stakeConfigAccount: string(),
+        stakeHistorySysvar: string(),
+        voteAccount: string()
+      }),
+      parsedTransactionInstructionType("StakeSplitInstruction", {
+        lamports: bigint(),
+        newSplitAccount: string(),
+        stakeAccount: string(),
+        stakeAuthority: string()
+      }),
+      parsedTransactionInstructionType("StakeWithdrawInstruction", {
+        clockSysvar: string(),
+        destination: string(),
+        lamports: bigint(),
+        stakeAccount: string(),
+        withdrawAuthority: string()
+      }),
+      parsedTransactionInstructionType("StakeDeactivateInstruction", {
+        clockSysvar: string(),
+        stakeAccount: string(),
+        stakeAuthority: string()
+      }),
+      parsedTransactionInstructionType("StakeSetLockupInstruction", {
+        custodian: string(),
+        lockup: type(lockup()),
+        stakeAccount: string()
+      }),
+      parsedTransactionInstructionType("StakeMergeInstruction", {
+        clockSysvar: string(),
+        destination: string(),
+        source: string(),
+        stakeAuthority: string(),
+        stakeHistorySysvar: string()
+      }),
+      parsedTransactionInstructionType("StakeAuthorizeWithSeedInstruction", {
+        authorityBase: string(),
+        authorityOwner: string(),
+        authoritySeed: string(),
+        authorityType: string(),
+        clockSysvar: string(),
+        custodian: string(),
+        newAuthorized: string(),
+        stakeAccount: string()
+      }),
+      parsedTransactionInstructionType("StakeInitializeCheckedInstruction", {
+        rentSysvar: string(),
+        stakeAccount: string(),
+        staker: string(),
+        withdrawer: string()
+      }),
+      parsedTransactionInstructionType("StakeAuthorizeCheckedInstruction", {
+        authority: string(),
+        authorityType: string(),
+        clockSysvar: string(),
+        custodian: string(),
+        newAuthority: string(),
+        stakeAccount: string()
+      }),
+      parsedTransactionInstructionType("StakeAuthorizeCheckedWithSeedInstruction", {
+        authorityBase: string(),
+        authorityOwner: string(),
+        authoritySeed: string(),
+        authorityType: string(),
+        clockSysvar: string(),
+        custodian: string(),
+        newAuthorized: string(),
+        stakeAccount: string()
+      }),
+      parsedTransactionInstructionType("StakeSetLockupCheckedInstruction", {
+        custodian: string(),
+        lockup: type(lockup()),
+        stakeAccount: string()
+      }),
+      parsedTransactionInstructionType("StakeDeactivateDelinquentInstruction", {
+        referenceVoteAccount: string(),
+        stakeAccount: string(),
+        voteAccount: string()
+      }),
+      parsedTransactionInstructionType("StakeRedelegateInstruction", {
+        newStakeAccount: string(),
+        stakeAccount: string(),
+        stakeAuthority: string(),
+        stakeConfigAccount: string(),
+        voteAccount: string()
+      })
+    ];
+  return memoisedParsedInstructionsStake;
+};
+var memoisedParsedInstructionsSystem;
+var parsedInstructionsSystem = () => {
+  if (!memoisedParsedInstructionsSystem)
+    memoisedParsedInstructionsSystem = [
+      parsedTransactionInstructionType("CreateAccountInstruction", {
+        lamports: bigint(),
+        newAccount: string(),
+        owner: string(),
+        source: string(),
+        space: bigint()
+      }),
+      parsedTransactionInstructionType("AssignInstruction", {
+        owner: string()
+      }),
+      parsedTransactionInstructionType("TransferInstruction", {
+        amount: string(),
+        lamports: number(),
+        source: string()
+      }),
+      parsedTransactionInstructionType("CreateAccountWithSeedInstruction", {
+        base: string(),
+        lamports: bigint(),
+        owner: string(),
+        seed: string(),
+        space: bigint()
+      }),
+      parsedTransactionInstructionType("AdvanceNonceAccountInstruction", {
+        nonceAccount: string(),
+        nonceAuthority: string(),
+        recentBlockhashesSysvar: string()
+      }),
+      parsedTransactionInstructionType("WithdrawNonceAccountInstruction", {
+        destination: string(),
+        lamports: bigint(),
+        nonceAccount: string(),
+        nonceAuthority: string(),
+        recentBlockhashesSysvar: string(),
+        rentSysvar: string()
+      }),
+      parsedTransactionInstructionType("InitializeNonceAccountInstruction", {
+        nonceAccount: string(),
+        nonceAuthority: string(),
+        recentBlockhashesSysvar: string(),
+        rentSysvar: string()
+      }),
+      parsedTransactionInstructionType("AuthorizeNonceAccountInstruction", {
+        newAuthorized: string(),
+        nonceAccount: string(),
+        nonceAuthority: string()
+      }),
+      parsedTransactionInstructionType("UpgradeNonceAccountInstruction", {
+        nonceAccount: string()
+      }),
+      parsedTransactionInstructionType("AllocateInstruction", {
+        account: string(),
+        space: bigint()
+      }),
+      parsedTransactionInstructionType("AllocateWithSeedInstruction", {
+        account: string(),
+        base: string(),
+        owner: string(),
+        seed: string(),
+        space: bigint()
+      }),
+      parsedTransactionInstructionType("AssignWithSeedInstruction", {
+        account: string(),
+        base: string(),
+        owner: string(),
+        seed: string()
+      }),
+      parsedTransactionInstructionType("TransferWithSeedInstruction", {
+        destination: string(),
+        lamports: bigint(),
+        source: string(),
+        sourceBase: string(),
+        sourceOwner: string(),
+        sourceSeed: string()
+      })
+    ];
+  return memoisedParsedInstructionsSystem;
+};
+var memoisedVote;
+var vote = () => {
+  if (!memoisedVote)
+    memoisedVote = new GraphQLObjectType({
+      fields: {
+        hash: string(),
+        slots: list(bigint()),
+        timestamp: bigint()
+      },
+      name: "Vote"
+    });
+  return memoisedVote;
+};
+var memoisedVoteStateUpdate;
+var voteStateUpdate = () => {
+  if (!memoisedVoteStateUpdate)
+    memoisedVoteStateUpdate = new GraphQLObjectType({
+      fields: {
+        hash: string(),
+        lockouts: list(
+          object("VoteStateUpdateLockout", {
+            confirmationCount: number(),
+            slot: bigint()
+          })
+        ),
+        root: bigint(),
+        timestamp: bigint()
+      },
+      name: "VoteStateUpdate"
+    });
+  return memoisedVoteStateUpdate;
+};
+var memoisedParsedInstructionsVote;
+var parsedInstructionsVote = () => {
+  if (!memoisedParsedInstructionsVote)
+    memoisedParsedInstructionsVote = [
+      parsedTransactionInstructionType("VoteInitializeAccountInstruction", {
+        authorizedVoter: string(),
+        authorizedWithdrawer: string(),
+        clockSysvar: string(),
+        commission: number(),
+        node: string(),
+        rentSysvar: string(),
+        voteAccount: string()
+      }),
+      parsedTransactionInstructionType("VoteAuthorizeInstruction", {
+        authority: string(),
+        authorityType: string(),
+        clockSysvar: string(),
+        newAuthority: string(),
+        voteAccount: string()
+      }),
+      parsedTransactionInstructionType("VoteAuthorizeWithSeedInstruction", {
+        authorityBaseKey: string(),
+        authorityOwner: string(),
+        authoritySeed: string(),
+        authorityType: string(),
+        clockSysvar: string(),
+        newAuthority: string(),
+        voteAccount: string()
+      }),
+      parsedTransactionInstructionType("VoteAuthorizeCheckedWithSeedInstruction", {
+        authorityBaseKey: string(),
+        authorityOwner: string(),
+        authoritySeed: string(),
+        authorityType: string(),
+        clockSysvar: string(),
+        newAuthority: string(),
+        voteAccount: string()
+      }),
+      parsedTransactionInstructionType("VoteVoteInstruction", {
+        clockSysvar: string(),
+        slotHashedSysvar: string(),
+        vote: type(vote()),
+        voteAccount: string(),
+        voteAuthority: string()
+      }),
+      parsedTransactionInstructionType("VoteUpdateVoteStateInstruction", {
+        hash: string(),
+        voteAccount: string(),
+        voteAuthority: string(),
+        voteStateUpdate: type(voteStateUpdate())
+      }),
+      parsedTransactionInstructionType("VoteUpdateVoteStateSwitchInstruction", {
+        hash: string(),
+        voteAccount: string(),
+        voteAuthority: string(),
+        voteStateUpdate: type(voteStateUpdate())
+      }),
+      parsedTransactionInstructionType("VoteCompactUpdateVoteStateInstruction", {
+        hash: string(),
+        voteAccount: string(),
+        voteAuthority: string(),
+        voteStateUpdate: type(voteStateUpdate())
+      }),
+      parsedTransactionInstructionType("VoteCompactUpdateVoteStateSwitchInstruction", {
+        hash: string(),
+        voteAccount: string(),
+        voteAuthority: string(),
+        voteStateUpdate: type(voteStateUpdate())
+      }),
+      parsedTransactionInstructionType("VoteWithdrawInstruction", {
+        destination: string(),
+        lamports: bigint(),
+        voteAccount: string(),
+        withdrawAuthority: string()
+      }),
+      parsedTransactionInstructionType("VoteUpdateValidatorIdentityInstruction", {
+        newValidatorIdentity: string(),
+        voteAccount: string(),
+        withdrawAuthority: string()
+      }),
+      parsedTransactionInstructionType("VoteUpdateCommissionInstruction", {
+        commission: string(),
+        voteAccount: string(),
+        withdrawAuthority: string()
+      }),
+      parsedTransactionInstructionType("VoteVoteSwitchInstruction", {
+        clockSysvar: string(),
+        hash: string(),
+        slotHashesSysvar: string(),
+        vote: type(vote()),
+        voteAccount: string(),
+        voteAuthority: string()
+      }),
+      parsedTransactionInstructionType("VoteAuthorizeCheckedInstruction", {
+        authority: string(),
+        authorityType: string(),
+        clockSysvar: string(),
+        newAuthority: string(),
+        voteAccount: string()
+      })
+    ];
+  return memoisedParsedInstructionsVote;
+};
+var memoisedTransactionMetaInterfaceFields;
+var transactionMetaInterfaceFields = () => {
+  if (!memoisedTransactionMetaInterfaceFields)
+    memoisedTransactionMetaInterfaceFields = {
+      computeUnitsConsumed: bigint(),
+      err: string(),
+      fee: bigint(),
+      format: string(),
+      loadedAddresses: type(transactionMetaLoadedAddresses()),
+      logMessages: list(string()),
+      postBalances: list(bigint()),
+      postTokenBalances: list(type(tokenBalance())),
+      preBalances: list(bigint()),
+      preTokenBalances: list(type(tokenBalance())),
+      returnData: type(returnData()),
+      rewards: list(type(reward())),
+      status: type(transactionStatus())
+    };
+  return memoisedTransactionMetaInterfaceFields;
+};
+var memoisedTransactionMetaInterface;
+var transactionMetaInterface = () => {
+  if (!memoisedTransactionMetaInterface)
+    memoisedTransactionMetaInterface = new GraphQLInterfaceType({
+      fields: {
+        ...transactionMetaInterfaceFields()
+      },
+      name: "TransactionMeta",
+      resolveType(meta) {
+        if (meta.format === "parsed") {
+          return "TransactionMetaParsed";
+        }
+        return "TransactionMetaUnparsed";
+      }
+    });
+  return memoisedTransactionMetaInterface;
+};
+var transactionMetaType = (name, description, innerInstructions) => new GraphQLObjectType({
+  description,
+  fields: {
+    ...transactionMetaInterfaceFields(),
+    innerInstructions
+  },
+  interfaces: [transactionMetaInterface()],
+  name
+});
+var memoisedTransactionMetaUnparsed;
+var transactionMetaUnparsed = () => {
+  if (!memoisedTransactionMetaUnparsed)
+    memoisedTransactionMetaUnparsed = transactionMetaType(
+      "TransactionMetaUnparsed",
+      "Non-parsed transaction meta",
+      list(
+        object("TransactionMetaInnerInstructionsUnparsed", {
+          index: number(),
+          instructions: list(
+            object("TransactionMetaInnerInstructionsUnparsedInstruction", {
+              index: number(),
+              instructions: list(type(transactionInstruction()))
+            })
+          )
+        })
+      )
+    );
+  return memoisedTransactionMetaUnparsed;
+};
+var memoisedTransactionMetaParsed;
+var transactionMetaParsed = () => {
+  if (!memoisedTransactionMetaParsed)
+    memoisedTransactionMetaParsed = transactionMetaType(
+      "TransactionMetaParsed",
+      "Parsed transaction meta",
+      list(
+        object("TransactionMetaInnerInstructionsParsed", {
+          index: number(),
+          instructions: list(type(parsedTransactionInstructionInterface()))
+        })
+      )
+    );
+  return memoisedTransactionMetaParsed;
+};
+var memoisedTransactionMessageInterfaceFields;
+var transactionMessageInterfaceFields = () => {
+  if (!memoisedTransactionMessageInterfaceFields)
+    memoisedTransactionMessageInterfaceFields = {
+      addressTableLookups: list(type(addressTableLookup())),
+      format: string(),
+      header: object("TransactionJsonTransactionHeader", {
+        numReadonlySignedAccounts: number(),
+        numReadonlyUnsignedAccounts: number(),
+        numRequiredSignatures: number()
+      }),
+      recentBlockhash: string()
+    };
+  return memoisedTransactionMessageInterfaceFields;
+};
+var memoisedTransactionMessageInterface;
+var transactionMessageInterface = () => {
+  if (!memoisedTransactionMessageInterface)
+    memoisedTransactionMessageInterface = new GraphQLInterfaceType({
+      fields: {
+        ...transactionMessageInterfaceFields()
+      },
+      name: "TransactionMessage",
+      resolveType(message) {
+        if (message.format === "parsed") {
+          return "TransactionMessageParsed";
+        }
+        return "TransactionMessageUnparsed";
+      }
+    });
+  return memoisedTransactionMessageInterface;
+};
+var transactionMessageType = (name, description, accountKeys, instructions) => new GraphQLObjectType({
+  description,
+  fields: {
+    ...transactionMessageInterfaceFields(),
+    accountKeys,
+    instructions
+  },
+  interfaces: [transactionMessageInterface()],
+  name
+});
+var memoisedTransactionMessageUnparsed;
+var transactionMessageUnparsed = () => {
+  if (!memoisedTransactionMessageUnparsed)
+    memoisedTransactionMessageUnparsed = transactionMessageType(
+      "TransactionMessageUnparsed",
+      "Non-parsed transaction message",
+      list(string()),
+      list(type(transactionInstruction()))
+    );
+  return memoisedTransactionMessageUnparsed;
+};
+var memoisedTransactionMessageParsed;
+var transactionMessageParsed = () => {
+  if (!memoisedTransactionMessageParsed)
+    memoisedTransactionMessageParsed = transactionMessageType(
+      "TransactionMessageParsed",
+      "Parsed transaction message",
+      list(
+        object("transactionMessageParsedAccountKey", {
+          pubkey: string(),
+          signer: boolean(),
+          source: string(),
+          writable: boolean()
+        })
+      ),
+      list(type(parsedTransactionInstructionInterface()))
+    );
+  return memoisedTransactionMessageParsed;
+};
+var memoisedTransactionTransaction;
+var transactionTransaction = () => {
+  if (!memoisedTransactionTransaction)
+    memoisedTransactionTransaction = new GraphQLObjectType({
+      fields: {
+        message: type(transactionMessageInterface()),
+        signatures: list(string())
+      },
+      name: "TransactionTransaction"
+    });
+  return memoisedTransactionTransaction;
+};
+var memoisedTransactionInterfaceFields;
+var transactionInterfaceFields = () => {
+  if (!memoisedTransactionInterfaceFields)
+    memoisedTransactionInterfaceFields = {
+      blockTime: bigint(),
+      encoding: string(),
+      meta: type(transactionMetaInterface()),
+      slot: bigint()
+    };
+  return memoisedTransactionInterfaceFields;
+};
+var memoisedTransactionInterface;
+var transactionInterface = () => {
+  if (!memoisedTransactionInterface)
+    memoisedTransactionInterface = new GraphQLInterfaceType({
+      fields: {
+        ...transactionInterfaceFields()
+      },
+      name: "Transaction",
+      resolveType(transaction) {
+        if (transaction.encoding === "base58") {
+          return "TransactionBase58";
+        }
+        if (transaction.encoding === "base64") {
+          return "TransactionBase64";
+        }
+        if (transaction.encoding === "json") {
+          return "TransactionJson";
+        }
+        return "TransactionJsonParsed";
+      }
+    });
+  return memoisedTransactionInterface;
+};
+var transactionType = (name, description, transaction) => new GraphQLObjectType({
+  description,
+  fields: {
+    ...transactionInterfaceFields(),
+    transaction
+  },
+  interfaces: [transactionInterface()],
+  name
+});
+var memoisedTransactionBase58;
+var transactionBase58 = () => {
+  if (!memoisedTransactionBase58)
+    memoisedTransactionBase58 = transactionType(
+      "TransactionBase58",
+      "A Solana transaction as base58 encoded data",
+      string()
+    );
+  return memoisedTransactionBase58;
+};
+var memoisedTransactionBase64;
+var transactionBase64 = () => {
+  if (!memoisedTransactionBase64)
+    memoisedTransactionBase64 = transactionType(
+      "TransactionBase64",
+      "A Solana transaction as base64 encoded data",
+      string()
+    );
+  return memoisedTransactionBase64;
+};
+var memoisedTransactionJson;
+var transactionJson = () => {
+  if (!memoisedTransactionJson)
+    memoisedTransactionJson = transactionType(
+      "TransactionJson",
+      "A Solana transaction as a JSON object",
+      type(transactionTransaction())
+    );
+  return memoisedTransactionJson;
+};
+var memoisedTransactionJsonParsed;
+var transactionJsonParsed = () => {
+  if (!memoisedTransactionJsonParsed)
+    memoisedTransactionJsonParsed = transactionType(
+      "TransactionJsonParsed",
+      "A Solana transaction as a parsed JSON object",
+      type(transactionTransaction())
+    );
+  return memoisedTransactionJsonParsed;
+};
+var memoisedTransactionTypes;
+var transactionTypes = () => {
+  if (!memoisedTransactionTypes)
+    memoisedTransactionTypes = [
+      partiallyDecodedTransactionInstruction(),
+      ...parsedInstructionsAddressLookupTable(),
+      ...parsedInstructionsBpfLoader(),
+      ...parsedInstructionsBpfUpgradeableLoader(),
+      ...parsedInstructionsStake(),
+      ...parsedInstructionsSplAssociatedToken(),
+      parsedInstructionSplMemo(),
+      ...parsedInstructionsSplToken(),
+      ...parsedInstructionsSystem(),
+      ...parsedInstructionsVote(),
+      transactionMetaUnparsed(),
+      transactionMetaParsed(),
+      transactionMessageUnparsed(),
+      transactionMessageParsed(),
+      transactionBase58(),
+      transactionBase64(),
+      transactionJson(),
+      transactionJsonParsed()
+    ];
+  return memoisedTransactionTypes;
+};
+
+// src/schema/transaction/query.ts
+var transactionQuery = () => ({
+  transaction: {
+    args: {
+      commitment: type(commitmentInputType()),
+      encoding: type(transactionEncodingInputType()),
+      maxSupportedTransactionVersion: type(maxSupportedTransactionVersionInputType()),
+      signature: nonNull(string())
+    },
+    resolve: (_parent, args, context) => context.resolveTransaction(args),
+    type: transactionInterface()
+  }
+});
+
+// src/schema/block/types.ts
+var memoisedTransactionForAccounts;
+var transactionForAccounts = () => {
+  if (!memoisedTransactionForAccounts)
+    memoisedTransactionForAccounts = new GraphQLObjectType({
+      fields: {
+        meta: object("TransactionMetaForAccounts", {
+          computeUnitsUsed: bigint(),
+          err: string(),
+          fee: bigint(),
+          format: string(),
+          loadedAddresses: type(transactionMetaLoadedAddresses()),
+          logMessages: list(string()),
+          postBalances: list(bigint()),
+          postTokenBalances: list(type(tokenBalance())),
+          preBalances: list(bigint()),
+          preTokenBalances: list(type(tokenBalance())),
+          returnData: type(returnData()),
+          rewards: list(type(reward())),
+          status: type(transactionStatus())
+        }),
+        transaction: type(transactionInterface()),
+        // TODO
+        version: string()
+      },
+      name: "TransactionForAccounts"
+    });
+  return memoisedTransactionForAccounts;
+};
+var memoisedBlockInterfaceFields;
+var blockInterfaceFields = () => {
+  if (!memoisedBlockInterfaceFields)
+    memoisedBlockInterfaceFields = {
+      blockHeight: bigint(),
+      blockTime: bigint(),
+      blockhash: string(),
+      parentSlot: bigint(),
+      previousBlockhash: string(),
+      rewards: list(type(reward()))
+    };
+  return memoisedBlockInterfaceFields;
+};
+var memoisedBlockInterface;
+var blockInterface = () => {
+  if (!memoisedBlockInterface)
+    memoisedBlockInterface = new GraphQLInterfaceType({
+      fields: {
+        ...blockInterfaceFields()
+      },
+      name: "Block",
+      resolveType(block) {
+        if (block.transactionDetails === "signatures") {
+          return "BlockWithSignatures";
+        }
+        if (block.transactionDetails === "accounts") {
+          return "BlockWithAccounts";
+        }
+        if (block.transactionDetails === "none") {
+          return "BlockWithNoTransactions";
+        }
+        return "BlockWithTransactions";
+      }
+    });
+  return memoisedBlockInterface;
+};
+var memoisedBlockWithNoTransactions;
+var blockWithNoTransactions = () => {
+  if (!memoisedBlockWithNoTransactions)
+    memoisedBlockWithNoTransactions = new GraphQLObjectType({
+      fields: {
+        ...blockInterfaceFields()
+      },
+      interfaces: [blockInterface()],
+      name: "BlockWithNoTransactions"
+    });
+  return memoisedBlockWithNoTransactions;
+};
+var memoisedBlockWithSignatures;
+var blockWithSignatures = () => {
+  if (!memoisedBlockWithSignatures)
+    memoisedBlockWithSignatures = new GraphQLObjectType({
+      fields: {
+        ...blockInterfaceFields(),
+        signatures: list(string())
+      },
+      interfaces: [blockInterface()],
+      name: "BlockWithSignatures"
+    });
+  return memoisedBlockWithSignatures;
+};
+var memoisedBlockWithAccounts;
+var blockWithAccounts = () => {
+  if (!memoisedBlockWithAccounts)
+    memoisedBlockWithAccounts = new GraphQLObjectType({
+      fields: {
+        ...blockInterfaceFields(),
+        transactions: list(type(transactionForAccounts()))
+      },
+      interfaces: [blockInterface()],
+      name: "BlockWithAccounts"
+    });
+  return memoisedBlockWithAccounts;
+};
+var memoisedBlockWithTransactions;
+var blockWithTransactions = () => {
+  if (!memoisedBlockWithTransactions)
+    memoisedBlockWithTransactions = new GraphQLObjectType({
+      fields: {
+        ...blockInterfaceFields(),
+        transactions: list(type(transactionInterface()))
+      },
+      interfaces: [blockInterface()],
+      name: "BlockWithTransactions"
+    });
+  return memoisedBlockWithTransactions;
+};
+var memoisedBlockTypes;
+var blockTypes = () => {
+  if (!memoisedBlockTypes)
+    memoisedBlockTypes = [
+      blockWithNoTransactions(),
+      blockWithSignatures(),
+      blockWithAccounts(),
+      blockWithTransactions()
+    ];
+  return memoisedBlockTypes;
+};
+
+// src/schema/block/query.ts
+var blockQuery = () => ({
+  block: {
+    args: {
+      commitment: type(commitmentInputType()),
+      encoding: type(transactionEncodingInputType()),
+      maxSupportedTransactionVersion: string(),
+      rewards: boolean(),
+      slot: nonNull(bigint()),
+      transactionDetails: type(blockTransactionDetailsInputType())
+    },
+    resolve: (_parent, args, context) => context.resolveBlock(args),
+    type: blockInterface()
+  }
+});
+var programAccountsQuery = () => ({
+  programAccounts: {
+    args: {
+      commitment: type(commitmentInputType()),
+      dataSlice: type(dataSliceInputType()),
+      encoding: type(accountEncodingInputType()),
+      filters: list(type(programAccountFilterInputType())),
+      minContextSlot: bigint(),
+      programAddress: nonNull(string()),
+      withContext: string()
+    },
+    resolve: (_parent, args, context) => context.resolveProgramAccounts(args),
+    type: new GraphQLList(accountInterface())
+  }
+});
 
 // src/rpc.ts
 function createRpcGraphQL(rpc) {
@@ -45,11 +2298,14 @@ function createRpcGraphQL(rpc) {
   const schema = new GraphQLSchema({
     query: new GraphQLObjectType({
       fields: {
-        /** Root queries */
+        ...accountQuery(),
+        ...blockQuery(),
+        ...programAccountsQuery(),
+        ...transactionQuery()
       },
       name: "RootQuery"
     }),
-    types: []
+    types: [...accountTypes(), ...blockTypes(), ...transactionTypes()]
   });
   return {
     context,