@solana/rpc-graphql 2.0.0-experimental.b153bb7 → 2.0.0-experimental.b315352

package/dist/index.node.cjs

@@ -1,43 +1,19 @@
 'use strict';
 
 var graphql = require('graphql');
+var DataLoader = require('dataloader');
+var fastStableStringify = require('fast-stable-stringify');
 var schema = require('@graphql-tools/schema');
 
-// src/rpc.ts
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-// src/cache.ts
-var inMemoryCache = {};
-var stringifyValue = (value) => JSON.stringify(value, (_, value2) => {
-  if (typeof value2 === "bigint") {
-    return value2.toString() + "n";
-  }
-  return value2;
-});
-var parseValue = (value) => JSON.parse(value, (_, value2) => {
-  if (typeof value2 === "string" && /\d+n$/.test(value2)) {
-    return BigInt(value2.slice(0, -1));
-  }
-  return value2;
-});
-var cacheKey = (key, variables) => `GraphQLCache:${stringifyValue(key)}:${stringifyValue(variables)}`;
-function createGraphQLCache() {
-  return {
-    // Node.js
-    flush: () => {
-      Object.keys(inMemoryCache).forEach((key) => delete inMemoryCache[key]);
-    },
-    get: (key, variables) => {
-      const value = inMemoryCache[cacheKey(key, variables)];
-      return value === void 0 ? null : parseValue(value);
-    },
-    insert: (key, variables, value) => {
-      inMemoryCache[cacheKey(key, variables)] = stringifyValue(value);
-    }
-  };
-}
+var DataLoader__default = /*#__PURE__*/_interopDefault(DataLoader);
+var fastStableStringify__default = /*#__PURE__*/_interopDefault(fastStableStringify);
 
-// src/loaders/account.ts
-function onlyAddressRequested(info) {
+// src/rpc.ts
+
+// src/loaders/common/resolve-info.ts
+function onlyPresentFieldRequested(fieldName, info) {
   if (info && info.fieldNodes[0].selectionSet) {
     const selectionSet = info.fieldNodes[0].selectionSet;
     const requestedFields = selectionSet.selections.map((field) => {
@@ -46,104 +22,206 @@ function onlyAddressRequested(info) {
       }
       return null;
     });
-    if (requestedFields && requestedFields.length === 1 && requestedFields[0] === "address") {
+    if (requestedFields && requestedFields.length === 1 && requestedFields[0] === fieldName) {
       return true;
     }
   }
   return false;
 }
-function refineJsonParsedAccountData(jsonParsedAccountData) {
-  const meta = {
-    program: jsonParsedAccountData.program,
-    space: jsonParsedAccountData.space,
-    type: jsonParsedAccountData.parsed.type
-  };
-  const data = jsonParsedAccountData.parsed.info;
-  return { data, meta };
+
+// src/loaders/transformers/account.ts
+function transformParsedAccountData(parsedAccountData) {
+  const {
+    parsed: { info: result, type: accountType },
+    program: programName,
+    programId
+  } = parsedAccountData;
+  result.accountType = accountType;
+  result.programId = programId;
+  result.programName = programName;
+  return result;
 }
-function processQueryResponse({ address, account, encoding }) {
-  const [refinedData, responseEncoding] = Array.isArray(account.data) ? encoding === "jsonParsed" ? [account.data[0], "base64"] : [account.data[0], encoding] : [refineJsonParsedAccountData(account.data), "jsonParsed"];
-  const responseBase = {
+function transformLoadedAccount({
+  account,
+  address,
+  encoding
+}) {
+  const [
+    // The account's data, either encoded or parsed.
+    data,
+    // Tells GraphQL which encoding has been returned
+    // by the RPC.
+    responseEncoding
+  ] = Array.isArray(account.data) ? encoding === "jsonParsed" ? (
+    // The requested encoding is jsonParsed,
+    // but the data could not be parsed.
+    // Defaults to base64 encoding.
+    [{ data: account.data[0] }, "base64"]
+  ) : (
+    // The requested encoding is base58,
+    // base64, or base64+zstd.
+    [{ data: account.data[0] }, encoding]
+  ) : (
+    // The account data was returned as an object,
+    // so it was parsed successfully.
+    [transformParsedAccountData(account.data), "jsonParsed"]
+  );
+  account.address = address;
+  account.encoding = responseEncoding;
+  account.ownerProgram = account.owner;
+  return {
     ...account,
-    address,
-    encoding: responseEncoding
+    ...data
   };
-  return typeof refinedData === "object" && "meta" in refinedData ? {
-    ...responseBase,
-    data: refinedData.data,
-    meta: refinedData.meta
-  } : {
-    ...responseBase,
-    data: refinedData
+}
+
+// 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)));
   };
 }
-async function loadAccount({ address, encoding = "jsonParsed", ...config }, cache, rpc, info) {
-  if (onlyAddressRequested(info)) {
-    return { address };
-  }
-  const requestConfig = { encoding, ...config };
-  const cached = cache.get(address, requestConfig);
-  if (cached !== null) {
-    return cached;
+function createAccountLoader(rpc) {
+  const loader = new DataLoader__default.default(createAccountBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
+  return {
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("address", info)) {
+        return { address: args.address };
+      }
+      return loader.load(normalizeArgs(args));
+    }
+  };
+}
+
+// src/loaders/transformers/transaction.ts
+function transformParsedInstruction(parsedInstruction) {
+  if ("parsed" in parsedInstruction) {
+    const {
+      parsed: { info: data, type: instructionType },
+      program: programName,
+      programId
+    } = parsedInstruction;
+    return { instructionType, programId, programName, ...data };
+  } else {
+    return parsedInstruction;
   }
-  const account = await rpc.getAccountInfo(address, requestConfig).send().then((res) => res.value).catch((e) => {
-    throw e;
+}
+function transformParsedTransaction(parsedTransaction) {
+  const transactionData = parsedTransaction.transaction;
+  const transactionMeta = parsedTransaction.meta;
+  transactionData.message.instructions = transactionData.message.instructions.map(transformParsedInstruction);
+  transactionMeta.innerInstructions = transactionMeta.innerInstructions.map((innerInstruction) => {
+    innerInstruction.instructions = innerInstruction.instructions.map(transformParsedInstruction);
+    return innerInstruction;
   });
-  if (account === null) {
-    return { address };
+  return [transactionData, transactionMeta];
+}
+function transformLoadedTransaction({ encoding, transaction }) {
+  const [transactionData, transactionMeta] = Array.isArray(transaction.transaction) ? (
+    // The requested encoding is base58 or base64.
+    [transaction.transaction[0], transaction.meta]
+  ) : (
+    // The transaction was either partially parsed or
+    // fully JSON-parsed, which will be sorted later.
+    transformParsedTransaction(transaction)
+  );
+  transaction.data = transactionData;
+  transaction.encoding = encoding;
+  transaction.meta = transactionMeta;
+  return transaction;
+}
+
+// src/loaders/transformers/block.ts
+function transformLoadedBlock({
+  encoding,
+  block,
+  transactionDetails
+}) {
+  if (typeof block === "object" && "transactions" in block) {
+    block.transactions = block.transactions.map((transaction) => {
+      if (transactionDetails === "accounts") {
+        return {
+          data: transaction.transaction,
+          meta: transaction.meta,
+          version: transaction.version
+        };
+      } else {
+        return transformLoadedTransaction({ encoding, transaction });
+      }
+    });
   }
-  const queryResponse = processQueryResponse({ account, address, encoding });
-  cache.insert(address, requestConfig, queryResponse);
-  return queryResponse;
+  block.encoding = encoding;
+  block.transactionDetails = transactionDetails;
+  return block;
 }
 
 // src/loaders/block.ts
-async function loadBlock({ slot, encoding = "jsonParsed", ...config }, cache, rpc, _info) {
-  const requestConfig = {
+function normalizeArgs2({
+  commitment = "confirmed",
+  encoding = "jsonParsed",
+  slot,
+  transactionDetails = "full"
+}) {
+  return {
+    commitment,
     encoding,
-    ...config,
     // Always use 0 to avoid silly errors
-    maxSupportedTransactionVersion: 0
+    maxSupportedTransactionVersion: 0,
+    slot,
+    transactionDetails
   };
-  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;
 }
-
-// src/loaders/program-accounts.ts
-function processQueryResponse2({ encoding, programAccounts }) {
-  return programAccounts.map((programAccount) => {
-    const [refinedData, responseEncoding] = Array.isArray(programAccount.account.data) ? encoding === "jsonParsed" ? [programAccount.account.data[0], "base64"] : [programAccount.account.data[0], encoding] : [refineJsonParsedAccountData(programAccount.account.data), "jsonParsed"];
-    const pubkey = programAccount.pubkey;
-    const responseBase = {
-      ...programAccount.account,
-      address: pubkey,
-      encoding: responseEncoding
-    };
-    return typeof refinedData === "object" && "meta" in refinedData ? {
-      ...responseBase,
-      data: refinedData.data,
-      meta: refinedData.meta
-    } : {
-      ...responseBase,
-      data: refinedData
-    };
+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 });
 }
-async function loadProgramAccounts({ programAddress, encoding = "jsonParsed", ...config }, cache, rpc, _info) {
-  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) => {
+function createBlockBatchLoadFn(rpc) {
+  const resolveBlockUsingRpc = loadBlock.bind(null, rpc);
+  return async (blockQueryArgs) => {
+    return await Promise.all(blockQueryArgs.map(async (args) => await resolveBlockUsingRpc(args)));
+  };
+}
+function createBlockLoader(rpc) {
+  const loader = new DataLoader__default.default(createBlockBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
+  return {
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("slot", info)) {
+        return { slot: args.slot };
+      }
+      return loader.load(normalizeArgs2(args));
+    }
+  };
+}
+function normalizeArgs3({
+  commitment = "confirmed",
+  dataSlice,
+  encoding = "jsonParsed",
+  filters,
+  minContextSlot,
+  programAddress
+}) {
+  return { commitment, dataSlice, encoding, filters, minContextSlot, programAddress };
+}
+async function loadProgramAccounts(rpc, { programAddress, ...config }) {
+  const programAccounts = await rpc.getProgramAccounts(programAddress, config).send().then((res) => {
     if ("value" in res) {
       return res.value;
     }
@@ -151,109 +229,87 @@ async function loadProgramAccounts({ programAddress, encoding = "jsonParsed", ..
   }).catch((e) => {
     throw e;
   });
-  const queryResponse = processQueryResponse2({ encoding, programAccounts });
-  cache.insert(programAddress, requestConfig, queryResponse);
-  return queryResponse;
-}
-
-// src/loaders/transaction.ts
-function refineJsonParsedInstructionData(jsonParsedInstructionData) {
-  if ("parsed" in jsonParsedInstructionData) {
-    const meta = {
-      program: jsonParsedInstructionData.program,
-      type: jsonParsedInstructionData.parsed.type
-    };
-    const programId = jsonParsedInstructionData.programId;
-    const data = jsonParsedInstructionData.parsed.info;
-    return { data, meta, programId };
-  } else {
-    return jsonParsedInstructionData;
-  }
-}
-function refineJsonParsedTransactionData(jsonParsedTransactionData) {
-  const refinedInstructions = jsonParsedTransactionData.message.instructions.map(
-    (instruction) => refineJsonParsedInstructionData(instruction)
+  return programAccounts.map(
+    (programAccount) => transformLoadedAccount({
+      account: programAccount.account,
+      address: programAccount.pubkey,
+      encoding: config.encoding
+    })
   );
-  const message = {
-    ...jsonParsedTransactionData.message,
-    instructions: refinedInstructions
-  };
-  return { message, signatures: jsonParsedTransactionData.signatures };
 }
-function refineJsonParsedTransactionMeta(jsonParsedTransactionMeta) {
-  const refinedInnerInstructions = jsonParsedTransactionMeta.innerInstructions.map(
-    ({ index, instructions }) => {
-      return {
-        index,
-        instructions: instructions.map((instruction) => refineJsonParsedInstructionData(instruction))
-      };
-    }
-  );
-  return {
-    ...jsonParsedTransactionMeta,
-    innerInstructions: refinedInnerInstructions
+function createProgramAccountsBatchLoadFn(rpc) {
+  const resolveProgramAccountsUsingRpc = loadProgramAccounts.bind(null, rpc);
+  return async (programAccountsQueryArgs) => {
+    return await Promise.all(
+      programAccountsQueryArgs.map(async (args) => await resolveProgramAccountsUsingRpc(args))
+    );
   };
 }
-function processQueryResponse3({ encoding, transaction }) {
-  const [transactionData, transactionMeta, responseEncoding] = Array.isArray(transaction.transaction) ? [transaction.transaction[0], transaction.meta, encoding] : [
-    refineJsonParsedTransactionData(transaction.transaction),
-    refineJsonParsedTransactionMeta(transaction.meta),
-    encoding
-  ];
+function createProgramAccountsLoader(rpc) {
+  const loader = new DataLoader__default.default(createProgramAccountsBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
   return {
-    ...transaction,
-    data: transactionData,
-    encoding: responseEncoding,
-    meta: transactionMeta
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("programAddress", info)) {
+        return { programAddress: args.programAddress };
+      }
+      return loader.load(normalizeArgs3(args));
+    }
   };
 }
-async function loadTransaction({ signature, encoding = "jsonParsed", ...config }, cache, rpc, _info) {
-  const requestConfig = {
+function normalizeArgs4({ commitment = "confirmed", encoding = "jsonParsed", signature }) {
+  return {
+    commitment,
     encoding,
-    ...config,
     // Always use 0 to avoid silly errors
-    maxSupportedTransactionVersion: 0
+    maxSupportedTransactionVersion: 0,
+    signature
   };
-  const cached = cache.get(signature, requestConfig);
-  if (cached !== null) {
-    return cached;
-  }
-  let transaction = await rpc.getTransaction(signature, requestConfig).send();
+}
+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, requestConfig).send();
+    const transactionJsonParsed = await rpc.getTransaction(signature, config).send().catch((e) => {
+      throw e;
+    });
     if (transactionJsonParsed === null) {
       return null;
     }
-    transaction = {
-      ...transaction,
-      meta: transactionJsonParsed.meta
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    };
+    transaction.meta = transactionJsonParsed.meta;
   }
-  const queryResponse = processQueryResponse3({ encoding, transaction });
-  cache.insert(signature, requestConfig, queryResponse);
-  return queryResponse;
+  return transformLoadedTransaction({ encoding, transaction });
+}
+function createTransactionBatchLoadFn(rpc) {
+  const resolveTransactionUsingRpc = loadTransaction.bind(null, rpc);
+  return async (transactionQueryArgs) => {
+    return await Promise.all(transactionQueryArgs.map(async (args) => await resolveTransactionUsingRpc(args)));
+  };
+}
+function createTransactionLoader(rpc) {
+  const loader = new DataLoader__default.default(createTransactionBatchLoadFn(rpc), { cacheKeyFn: fastStableStringify__default.default });
+  return {
+    load: async (args, info) => {
+      if (onlyPresentFieldRequested("signature", info)) {
+        return { signature: args.signature };
+      }
+      return loader.load(normalizeArgs4(args));
+    }
+  };
 }
 
 // src/context.ts
 function createSolanaGraphQLContext(rpc) {
-  const cache = createGraphQLCache();
   return {
-    cache,
-    loadAccount(args, info) {
-      return loadAccount(args, this.cache, this.rpc, info);
-    },
-    loadBlock(args, info) {
-      return loadBlock(args, this.cache, this.rpc);
-    },
-    loadProgramAccounts(args, info) {
-      return loadProgramAccounts(args, this.cache, this.rpc);
-    },
-    loadTransaction(args, info) {
-      return loadTransaction(args, this.cache, this.rpc);
+    loaders: {
+      account: createAccountLoader(rpc),
+      block: createBlockLoader(rpc),
+      programAccounts: createProgramAccountsLoader(rpc),
+      transaction: createTransactionLoader(rpc)
     },
     rpc
   };
@@ -261,7 +317,7 @@ function createSolanaGraphQLContext(rpc) {
 
 // src/resolvers/account.ts
 var resolveAccount = (fieldName) => {
-  return (parent, args, context, info) => parent[fieldName] === null ? null : context.loadAccount({ ...args, address: parent[fieldName] }, info);
+  return (parent, args, context, info) => parent[fieldName] === null ? null : context.loaders.account.load({ ...args, address: parent[fieldName] }, info);
 };
 
 // src/schema/account.ts
@@ -270,133 +326,107 @@ var accountTypeDefs = (
   `
     # Account interface
     interface Account {
-        address: String
-        encoding: String
+        address: Address
         executable: Boolean
         lamports: BigInt
-        owner: Account
+        ownerProgram: Account
+        space: BigInt
         rentEpoch: BigInt
     }
 
     # An account with base58 encoded data
     type AccountBase58 implements Account {
-        address: String
-        data: String
-        encoding: String
+        address: Address
+        data: Base58EncodedBytes
         executable: Boolean
         lamports: BigInt
-        owner: Account
+        ownerProgram: Account
+        space: BigInt
         rentEpoch: BigInt
     }
 
     # An account with base64 encoded data
     type AccountBase64 implements Account {
-        address: String
-        data: String
-        encoding: String
+        address: Address
+        data: Base64EncodedBytes
         executable: Boolean
         lamports: BigInt
-        owner: Account
+        ownerProgram: Account
+        space: BigInt
         rentEpoch: BigInt
     }
 
     # An account with base64+zstd encoded data
     type AccountBase64Zstd implements Account {
-        address: String
-        data: String
-        encoding: String
+        address: Address
+        data: Base64ZstdEncodedBytes
         executable: Boolean
         lamports: BigInt
-        owner: Account
-        rentEpoch: BigInt
-    }
-
-    # Interface for JSON-parsed meta
-    type JsonParsedAccountMeta {
-        program: String
+        ownerProgram: Account
         space: BigInt
-        type: String
-    }
-    interface AccountJsonParsed {
-        meta: JsonParsedAccountMeta
+        rentEpoch: BigInt
     }
 
     # A nonce account
     type NonceAccountFeeCalculator {
         lamportsPerSignature: String
     }
-    type NonceAccountData {
+    type NonceAccount implements Account {
+        address: Address
+        executable: Boolean
+        lamports: BigInt
+        ownerProgram: Account
+        space: BigInt
+        rentEpoch: BigInt
         authority: Account
         blockhash: String
         feeCalculator: NonceAccountFeeCalculator
     }
-    type NonceAccount implements Account & AccountJsonParsed {
-        address: String
-        data: NonceAccountData
-        encoding: String
+
+    # A lookup table account
+    type LookupTableAccount implements Account {
+        address: Address
         executable: Boolean
         lamports: BigInt
-        meta: JsonParsedAccountMeta
-        owner: Account
+        ownerProgram: Account
+        space: BigInt
         rentEpoch: BigInt
-    }
-
-    # A lookup table account
-    type LookupTableAccountData {
-        addresses: [String]
+        addresses: [Address]
         authority: Account
         deactivationSlot: String
         lastExtendedSlot: String
         lastExtendedSlotStartIndex: Int
     }
-    type LookupTableAccount implements Account & AccountJsonParsed {
-        address: String
-        data: LookupTableAccountData
-        encoding: String
+
+    # A mint account
+    type MintAccount implements Account {
+        address: Address
         executable: Boolean
         lamports: BigInt
-        meta: JsonParsedAccountMeta
-        owner: Account
+        ownerProgram: Account
+        space: BigInt
         rentEpoch: BigInt
-    }
-
-    # A mint account
-    type MintAccountData {
         decimals: Int
         freezeAuthority: Account
         isInitialized: Boolean
         mintAuthority: Account
         supply: String
     }
-    type MintAccount implements Account & AccountJsonParsed {
-        address: String
-        data: MintAccountData
-        encoding: String
+
+    # A token account
+    type TokenAccount implements Account {
+        address: Address
         executable: Boolean
         lamports: BigInt
-        meta: JsonParsedAccountMeta
-        owner: Account
+        ownerProgram: Account
+        space: BigInt
         rentEpoch: BigInt
-    }
-
-    # A token account
-    type TokenAccountData {
         isNative: Boolean
         mint: Account
         owner: Account
         state: String
         tokenAmount: TokenAmount
     }
-    type TokenAccount implements Account & AccountJsonParsed {
-        address: String
-        data: TokenAccountData
-        encoding: String
-        executable: Boolean
-        lamports: BigInt
-        meta: JsonParsedAccountMeta
-        owner: Account
-        rentEpoch: BigInt
-    }
 
     # A stake account
     type StakeAccountDataMetaAuthorized {
@@ -424,19 +454,15 @@ var accountTypeDefs = (
         creditsObserved: BigInt
         delegation: StakeAccountDataStakeDelegation
     }
-    type StakeAccountData {
-        meta: StakeAccountDataMeta
-        stake: StakeAccountDataStake
-    }
-    type StakeAccount implements Account & AccountJsonParsed {
-        address: String
-        data: StakeAccountData
-        encoding: String
+    type StakeAccount implements Account {
+        address: Address
         executable: Boolean
         lamports: BigInt
-        meta: JsonParsedAccountMeta
-        owner: Account
+        ownerProgram: Account
+        space: BigInt
         rentEpoch: BigInt
+        meta: StakeAccountDataMeta
+        stake: StakeAccountDataStake
     }
 
     # A vote account
@@ -457,27 +483,23 @@ var accountTypeDefs = (
         confirmationCount: Int
         slot: BigInt
     }
-    type VoteAccountData {
+    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: [String]
+        priorVoters: [Address]
         rootSlot: BigInt
         votes: [VoteAccountDataVote]
     }
-    type VoteAccount implements Account & AccountJsonParsed {
-        address: String
-        data: VoteAccountData
-        encoding: String
-        executable: Boolean
-        lamports: BigInt
-        meta: JsonParsedAccountMeta
-        owner: Account
-        rentEpoch: BigInt
-    }
 `
 );
 var accountResolvers = {
@@ -493,22 +515,22 @@ var accountResolvers = {
         return "AccountBase64Zstd";
       }
       if (account.encoding === "jsonParsed") {
-        if (account.meta.program === "nonce") {
+        if (account.programName === "nonce") {
           return "NonceAccount";
         }
-        if (account.meta.type === "mint" && account.meta.program === "spl-token") {
+        if (account.accountType === "mint" && account.programName === "spl-token") {
           return "MintAccount";
         }
-        if (account.meta.type === "account" && account.meta.program === "spl-token") {
+        if (account.accountType === "account" && account.programName === "spl-token") {
           return "TokenAccount";
         }
-        if (account.meta.program === "stake") {
+        if (account.programName === "stake") {
           return "StakeAccount";
         }
-        if (account.meta.type === "vote" && account.meta.program === "vote") {
+        if (account.accountType === "vote" && account.programName === "vote") {
           return "VoteAccount";
         }
-        if (account.meta.type === "lookupTable" && account.meta.program === "address-lookup-table") {
+        if (account.accountType === "lookupTable" && account.programName === "address-lookup-table") {
           return "LookupTableAccount";
         }
       }
@@ -516,39 +538,31 @@ var accountResolvers = {
     }
   },
   AccountBase58: {
-    owner: resolveAccount("owner")
+    ownerProgram: resolveAccount("ownerProgram")
   },
   AccountBase64: {
-    owner: resolveAccount("owner")
+    ownerProgram: resolveAccount("ownerProgram")
   },
   AccountBase64Zstd: {
-    owner: resolveAccount("owner")
-  },
-  NonceAccountData: {
-    authority: resolveAccount("authority")
+    ownerProgram: resolveAccount("ownerProgram")
   },
   NonceAccount: {
-    owner: resolveAccount("owner")
-  },
-  LookupTableAccountData: {
-    authority: resolveAccount("authority")
+    authority: resolveAccount("authority"),
+    ownerProgram: resolveAccount("ownerProgram")
   },
   LookupTableAccount: {
-    owner: resolveAccount("owner")
-  },
-  MintAccountData: {
-    freezeAuthority: resolveAccount("freezeAuthority"),
-    mintAuthority: resolveAccount("mintAuthority")
+    authority: resolveAccount("authority"),
+    ownerProgram: resolveAccount("ownerProgram")
   },
   MintAccount: {
-    owner: resolveAccount("owner")
-  },
-  TokenAccountData: {
-    mint: resolveAccount("mint"),
-    owner: resolveAccount("owner")
+    freezeAuthority: resolveAccount("freezeAuthority"),
+    mintAuthority: resolveAccount("mintAuthority"),
+    ownerProgram: resolveAccount("ownerProgram")
   },
   TokenAccount: {
-    owner: resolveAccount("owner")
+    mint: resolveAccount("mint"),
+    owner: resolveAccount("owner"),
+    ownerProgram: resolveAccount("ownerProgram")
   },
   StakeAccountDataMetaAuthorized: {
     staker: resolveAccount("staker"),
@@ -561,17 +575,15 @@ var accountResolvers = {
     voter: resolveAccount("voter")
   },
   StakeAccount: {
-    owner: resolveAccount("owner")
+    ownerProgram: resolveAccount("ownerProgram")
   },
   VoteAccountDataAuthorizedVoter: {
     authorizedVoter: resolveAccount("authorizedVoter")
   },
-  VoteAccountData: {
-    authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
-    node: resolveAccount("nodePubkey")
-  },
   VoteAccount: {
-    owner: resolveAccount("owner")
+    authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
+    node: resolveAccount("nodePubkey"),
+    ownerProgram: resolveAccount("ownerProgram")
   }
 };
 
@@ -590,7 +602,7 @@ var blockTypeDefs = (
     }
 
     type TransactionDataForAccounts {
-        accountKeys: [String]
+        accountKeys: [Address]
         signatures: [String]
     }
 
@@ -602,84 +614,84 @@ var blockTypeDefs = (
 
     # Block interface
     interface Block {
-        blockHeight: BigInt
-        blockTime: BigInt
         blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
         parentSlot: BigInt
         previousBlockhash: String
         rewards: [Reward]
+        transactionDetails: String
     }
 
     # A block with account transaction details
-    type BlockWithAccounts {
-        blockHeight: BigInt
-        blockTime: BigInt
+    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 BlockFull {
-        blockHeight: BigInt
-        blockTime: BigInt
+    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 {
-        blockHeight: BigInt
-        blockTime: BigInt
+    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 {
-        blockHeight: BigInt
-        blockTime: BigInt
+    type BlockWithSignatures implements Block {
         blockhash: String
+        blockHeight: BigInt
+        blockTime: Int
         parentSlot: BigInt
         previousBlockhash: String
         rewards: [Reward]
         signatures: [String]
+        transactionDetails: String
     }
 `
 );
-var blockResolvers = {};
+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 */
   `
-    enum AccountEncoding {
-        base58
-        base64
-        base64Zstd
-        jsonParsed
-    }
-
-    enum BlockTransactionDetails {
-        accounts
-        full
-        none
-        signatures
-    }
-
-    enum Commitment {
-        confirmed
-        finalized
-        processed
-    }
-
     input DataSlice {
         offset: Int
         length: Int
@@ -688,37 +700,41 @@ var inputTypeDefs = (
     input ProgramAccountsFilter {
         bytes: BigInt
         dataSize: BigInt
-        encoding: String
+        encoding: AccountEncoding
         offset: BigInt
     }
-
-    enum TransactionEncoding {
-        base58
-        base64
-        jsonParsed
-    }
-
-    enum TransactionVersion {
-        legacy
-        zero
-    }
 `
 );
-var inputResolvers = {
-  AccountEncoding: {
-    base64Zstd: "base64+zstd"
-  },
-  TransactionVersion: {
-    zero: 0
-  }
-};
+var inputResolvers = {};
 var scalarTypeDefs = (
   /* GraphQL */
   `
+    scalar Address
+    scalar Base58EncodedBytes
+    scalar Base64EncodedBytes
+    scalar Base64ZstdEncodedBytes
     scalar BigInt
 `
 );
+var stringScalarAlias = {
+  __parseLiteral(ast) {
+    if (ast.kind === graphql.Kind.STRING) {
+      return ast.value.toString();
+    }
+    return null;
+  },
+  __parseValue(value) {
+    return value;
+  },
+  __serialize(value) {
+    return value;
+  }
+};
 var scalarResolvers = {
+  Address: stringScalarAlias,
+  Base58EncodedBytes: stringScalarAlias,
+  Base64EncodedBytes: stringScalarAlias,
+  Base64ZstdEncodedBytes: stringScalarAlias,
   BigInt: {
     __parseLiteral(ast) {
       if (ast.kind === graphql.Kind.STRING) {
@@ -739,16 +755,36 @@ var scalarResolvers = {
 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: String
-        programId: String
+        data: Base64EncodedBytes
+        programId: Address
     }
 
     type Reward {
         commission: Int
         lamports: BigInt
         postBalance: BigInt
-        pubkey: String
+        pubkey: Address
         rewardType: String
     }
 
@@ -763,15 +799,41 @@ var commonTypeDefs = (
         accountIndex: Int
         mint: Account
         owner: Account
-        programId: String
+        programId: Address
         uiTokenAmount: TokenAmount
     }
+
+    enum TransactionEncoding {
+        BASE_58
+        BASE_64
+        PARSED
+    }
+
+    enum TransactionVersion {
+        LEGACY
+        ZERO
+    }
 `
 );
 var commonResolvers = {
+  AccountEncoding: {
+    BASE_58: "base58",
+    BASE_64: "base64",
+    BASE_64_ZSTD: "base64+zstd",
+    PARSED: "jsonParsed"
+  },
   TokenBalance: {
     mint: resolveAccount("mint"),
     owner: resolveAccount("owner")
+  },
+  TransactionEncoding: {
+    BASE_58: "base58",
+    BASE_64: "base64",
+    PARSED: "jsonParsed"
+  },
+  TransactionVersion: {
+    LEGACY: "legacy",
+    ZERO: 0
   }
 };
 
@@ -779,25 +841,21 @@ var commonResolvers = {
 var instructionTypeDefs = (
   /* GraphQL */
   `
-    type JsonParsedInstructionMeta {
-        program: String
-        type: String
-    }
-
     # Transaction instruction interface
     interface TransactionInstruction {
-        programId: String
+        programId: Address
     }
 
     # Generic transaction instruction
     type GenericInstruction implements TransactionInstruction {
-        accounts: [String]
-        data: String
-        programId: String
+        accounts: [Address]
+        data: Base64EncodedBytes
+        programId: Address
     }
 
     # AddressLookupTable: CreateLookupTable
-    type CreateLookupTableInstructionData {
+    type CreateLookupTableInstruction implements TransactionInstruction {
+        programId: Address
         bumpSeed: BigInt # FIXME:*
         lookupTableAccount: Account
         lookupTableAuthority: Account
@@ -805,221 +863,154 @@ var instructionTypeDefs = (
         recentSlot: BigInt
         systemProgram: Account
     }
-    type CreateLookupTableInstruction implements TransactionInstruction {
-        data: CreateLookupTableInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # AddressLookupTable: ExtendLookupTable
-    type ExtendLookupTableInstructionData {
+    type ExtendLookupTableInstruction implements TransactionInstruction {
+        programId: Address
         lookupTableAccount: Account
         lookupTableAuthority: Account
-        newAddresses: [String]
+        newAddresses: [Address]
         payerAccount: Account
         systemProgram: Account
     }
-    type ExtendLookupTableInstruction implements TransactionInstruction {
-        data: ExtendLookupTableInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # AddressLookupTable: FreezeLookupTable
-    type FreezeLookupTableInstructionData {
+    type FreezeLookupTableInstruction implements TransactionInstruction {
+        programId: Address
         lookupTableAccount: Account
         lookupTableAuthority: Account
     }
-    type FreezeLookupTableInstruction implements TransactionInstruction {
-        data: FreezeLookupTableInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # AddressLookupTable: DeactivateLookupTable
-    type DeactivateLookupTableInstructionData {
+    type DeactivateLookupTableInstruction implements TransactionInstruction {
+        programId: Address
         lookupTableAccount: Account
         lookupTableAuthority: Account
     }
-    type DeactivateLookupTableInstruction implements TransactionInstruction {
-        data: DeactivateLookupTableInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # AddressLookupTable: CloseLookupTable
-    type CloseLookupTableInstructionData {
+    type CloseLookupTableInstruction implements TransactionInstruction {
+        programId: Address
         lookupTableAccount: Account
         lookupTableAuthority: Account
         recipient: Account
     }
-    type CloseLookupTableInstruction implements TransactionInstruction {
-        data: CloseLookupTableInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # BpfLoader: Write
-    type BpfLoaderWriteInstructionData {
+    type BpfLoaderWriteInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
-        bytes: String
+        bytes: Base64EncodedBytes
         offset: BigInt # FIXME:*
     }
-    type BpfLoaderWriteInstruction implements TransactionInstruction {
-        data: BpfLoaderWriteInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # BpfLoader: Finalize
-    type BpfLoaderFinalizeInstructionData {
-        account: Account
-    }
     type BpfLoaderFinalizeInstruction implements TransactionInstruction {
-        data: BpfLoaderFinalizeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        programId: Address
+        account: Account
     }
 
     # BpfUpgradeableLoader: InitializeBuffer
-    type BpfUpgradeableLoaderInitializeBufferInstructionData {
-        account: Account
-    }
     type BpfUpgradeableLoaderInitializeBufferInstruction implements TransactionInstruction {
-        data: BpfUpgradeableLoaderInitializeBufferInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        programId: Address
+        account: Account
     }
 
     # BpfUpgradeableLoader: Write
-    type BpfUpgradeableLoaderWriteInstructionData {
+    type BpfUpgradeableLoaderWriteInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         authority: Account
-        bytes: String
+        bytes: Base64EncodedBytes
         offset: BigInt # FIXME:*
     }
-    type BpfUpgradeableLoaderWriteInstruction implements TransactionInstruction {
-        data: BpfUpgradeableLoaderWriteInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # BpfUpgradeableLoader: DeployWithMaxDataLen
-    type BpfUpgradeableLoaderDeployWithMaxDataLenInstructionData {
+    type BpfUpgradeableLoaderDeployWithMaxDataLenInstruction implements TransactionInstruction {
+        programId: Address
         authority: Account
         bufferAccount: Account
-        clockSysvar: String
+        clockSysvar: Address
         maxDataLen: BigInt
         payerAccount: Account
         programAccount: Account
         programDataAccount: Account
-        rentSysvar: String
-    }
-    type BpfUpgradeableLoaderDeployWithMaxDataLenInstruction implements TransactionInstruction {
-        data: BpfUpgradeableLoaderDeployWithMaxDataLenInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        rentSysvar: Address
     }
 
     # BpfUpgradeableLoader: Upgrade
-    type BpfUpgradeableLoaderUpgradeInstructionData {
+    type BpfUpgradeableLoaderUpgradeInstruction implements TransactionInstruction {
+        programId: Address
         authority: Account
         bufferAccount: Account
-        clockSysvar: String
+        clockSysvar: Address
         programAccount: Account
         programDataAccount: Account
-        rentSysvar: String
+        rentSysvar: Address
         spillAccount: Account
     }
-    type BpfUpgradeableLoaderUpgradeInstruction implements TransactionInstruction {
-        data: BpfUpgradeableLoaderUpgradeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # BpfUpgradeableLoader: SetAuthority
-    type BpfUpgradeableLoaderSetAuthorityInstructionData {
+
+    type BpfUpgradeableLoaderSetAuthorityInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         authority: Account
         newAuthority: Account
     }
-    type BpfUpgradeableLoaderSetAuthorityInstruction implements TransactionInstruction {
-        data: BpfUpgradeableLoaderSetAuthorityInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # BpfUpgradeableLoader: SetAuthorityChecked
-    type BpfUpgradeableLoaderSetAuthorityCheckedInstructionData {
+    type BpfUpgradeableLoaderSetAuthorityCheckedInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         authority: Account
         newAuthority: Account
     }
-    type BpfUpgradeableLoaderSetAuthorityCheckedInstruction implements TransactionInstruction {
-        data: BpfUpgradeableLoaderSetAuthorityCheckedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # BpfUpgradeableLoader: Close
-    type BpfUpgradeableLoaderCloseInstructionData {
+    type BpfUpgradeableLoaderCloseInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         authority: Account
         programAccount: Account
         recipient: Account
     }
-    type BpfUpgradeableLoaderCloseInstruction implements TransactionInstruction {
-        data: BpfUpgradeableLoaderCloseInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # BpfUpgradeableLoader: ExtendProgram
-    type BpfUpgradeableLoaderExtendProgramInstructionData {
+    type BpfUpgradeableLoaderExtendProgramInstruction implements TransactionInstruction {
+        programId: Address
         additionalBytes: BigInt
         payerAccount: Account
         programAccount: Account
         programDataAccount: Account
         systemProgram: Account
     }
-    type BpfUpgradeableLoaderExtendProgramInstruction implements TransactionInstruction {
-        data: BpfUpgradeableLoaderExtendProgramInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplAssociatedTokenAccount: Create
-    type SplAssociatedTokenCreateInstructionData {
+    type SplAssociatedTokenCreateInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
-        mint: String
+        mint: Address
         source: Account
         systemProgram: Account
         tokenProgram: Account
         wallet: Account
     }
-    type SplAssociatedTokenCreateInstruction implements TransactionInstruction {
-        data: SplAssociatedTokenCreateInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplAssociatedTokenAccount: CreateIdempotent
-    type SplAssociatedTokenCreateIdempotentInstructionData {
+    type SplAssociatedTokenCreateIdempotentInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
-        mint: String
+        mint: Address
         source: Account
         systemProgram: Account
         tokenProgram: Account
         wallet: Account
     }
-    type SplAssociatedTokenCreateIdempotentInstruction implements TransactionInstruction {
-        data: SplAssociatedTokenCreateIdempotentInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplAssociatedTokenAccount: RecoverNested
-    type SplAssociatedTokenRecoverNestedInstructionData {
+    type SplAssociatedTokenRecoverNestedInstruction implements TransactionInstruction {
+        programId: Address
         destination: Account
         nestedMint: Account
         nestedOwner: Account
@@ -1028,167 +1019,115 @@ var instructionTypeDefs = (
         tokenProgram: Account
         wallet: Account
     }
-    type SplAssociatedTokenRecoverNestedInstruction implements TransactionInstruction {
-        data: SplAssociatedTokenRecoverNestedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplMemo
-    type SplMemoInstructionData {
-        data: String
-    }
     type SplMemoInstruction implements TransactionInstruction {
-        data: SplMemoInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        programId: Address
+        data: String
     }
 
     # SplToken: InitializeMint
-    type SplTokenInitializeMintInstructionData {
+    type SplTokenInitializeMintInstruction implements TransactionInstruction {
+        programId: Address
         decimals: BigInt # FIXME:*
         freezeAuthority: Account
         mint: Account
         mintAuthority: Account
-        rentSysvar: String
-    }
-    type SplTokenInitializeMintInstruction implements TransactionInstruction {
-        data: SplTokenInitializeMintInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        rentSysvar: Address
     }
 
     # SplToken: InitializeMint2
-    type SplTokenInitializeMint2InstructionData {
+    type SplTokenInitializeMint2Instruction implements TransactionInstruction {
+        programId: Address
         decimals: BigInt # FIXME:*
         freezeAuthority: Account
         mint: Account
         mintAuthority: Account
     }
-    type SplTokenInitializeMint2Instruction implements TransactionInstruction {
-        data: SplTokenInitializeMint2InstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: InitializeAccount
-    type SplTokenInitializeAccountInstructionData {
+    type SplTokenInitializeAccountInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         mint: Account
         owner: Account
-        rentSysvar: String
-    }
-    type SplTokenInitializeAccountInstruction implements TransactionInstruction {
-        data: SplTokenInitializeAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        rentSysvar: Address
     }
 
     # SplToken: InitializeAccount2
-    type SplTokenInitializeAccount2InstructionData {
+    type SplTokenInitializeAccount2Instruction implements TransactionInstruction {
+        programId: Address
         account: Account
         mint: Account
         owner: Account
-        rentSysvar: String
-    }
-    type SplTokenInitializeAccount2Instruction implements TransactionInstruction {
-        data: SplTokenInitializeAccount2InstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        rentSysvar: Address
     }
 
     # SplToken: InitializeAccount3
-    type SplTokenInitializeAccount3InstructionData {
+    type SplTokenInitializeAccount3Instruction implements TransactionInstruction {
+        programId: Address
         account: Account
         mint: Account
         owner: Account
     }
-    type SplTokenInitializeAccount3Instruction implements TransactionInstruction {
-        data: SplTokenInitializeAccount3InstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: InitializeMultisig
-    type SplTokenInitializeMultisigInstructionData {
+    type SplTokenInitializeMultisigInstruction implements TransactionInstruction {
+        programId: Address
         m: BigInt # FIXME:*
         multisig: Account
-        rentSysvar: String
-        signers: [String]
-    }
-    type SplTokenInitializeMultisigInstruction implements TransactionInstruction {
-        data: SplTokenInitializeMultisigInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        rentSysvar: Address
+        signers: [Address]
     }
 
     # SplToken: InitializeMultisig2
-    type SplTokenInitializeMultisig2InstructionData {
+    type SplTokenInitializeMultisig2Instruction implements TransactionInstruction {
+        programId: Address
         m: BigInt # FIXME:*
         multisig: Account
-        signers: [String]
-    }
-    type SplTokenInitializeMultisig2Instruction implements TransactionInstruction {
-        data: SplTokenInitializeMultisig2InstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        signers: [Address]
     }
 
     # SplToken: Transfer
-    type SplTokenTransferInstructionData {
+    type SplTokenTransferInstruction implements TransactionInstruction {
+        programId: Address
         amount: String
         authority: Account
         destination: Account
         multisigAuthority: Account
         source: Account
     }
-    type SplTokenTransferInstruction implements TransactionInstruction {
-        data: SplTokenTransferInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: Approve
-    type SplTokenApproveInstructionData {
+    type SplTokenApproveInstruction implements TransactionInstruction {
+        programId: Address
         amount: String
         delegate: Account
         multisigOwner: Account
         owner: Account
         source: Account
     }
-    type SplTokenApproveInstruction implements TransactionInstruction {
-        data: SplTokenApproveInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: Revoke
-    type SplTokenRevokeInstructionData {
+    type SplTokenRevokeInstruction implements TransactionInstruction {
+        programId: Address
         multisigOwner: Account
         owner: Account
         source: Account
     }
-    type SplTokenRevokeInstruction implements TransactionInstruction {
-        data: SplTokenRevokeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: SetAuthority
-    type SplTokenSetAuthorityInstructionData {
+    type SplTokenSetAuthorityInstruction implements TransactionInstruction {
+        programId: Address
         authority: Account
         authorityType: String
         multisigAuthority: Account
         newAuthority: Account
     }
-    type SplTokenSetAuthorityInstruction implements TransactionInstruction {
-        data: SplTokenSetAuthorityInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: MintTo
-    type SplTokenMintToInstructionData {
+    type SplTokenMintToInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         amount: String
         authority: Account
@@ -1196,67 +1135,47 @@ var instructionTypeDefs = (
         mintAuthority: Account
         multisigMintAuthority: Account
     }
-    type SplTokenMintToInstruction implements TransactionInstruction {
-        data: SplTokenMintToInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: Burn
-    type SplTokenBurnInstructionData {
+    type SplTokenBurnInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         amount: String
         authority: Account
         mint: Account
         multisigAuthority: Account
     }
-    type SplTokenBurnInstruction implements TransactionInstruction {
-        data: SplTokenBurnInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: CloseAccount
-    type SplTokenCloseAccountInstructionData {
+    type SplTokenCloseAccountInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         destination: Account
         multisigOwner: Account
         owner: Account
     }
-    type SplTokenCloseAccountInstruction implements TransactionInstruction {
-        data: SplTokenCloseAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: FreezeAccount
-    type SplTokenFreezeAccountInstructionData {
+    type SplTokenFreezeAccountInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         freezeAuthority: Account
         mint: Account
         multisigFreezeAuthority: Account
     }
-    type SplTokenFreezeAccountInstruction implements TransactionInstruction {
-        data: SplTokenFreezeAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: ThawAccount
-    type SplTokenThawAccountInstructionData {
+    type SplTokenThawAccountInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         freezeAuthority: Account
         mint: Account
         multisigFreezeAuthority: Account
     }
-    type SplTokenThawAccountInstruction implements TransactionInstruction {
-        data: SplTokenThawAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: TransferChecked
-    type SplTokenTransferCheckedInstructionData {
+    type SplTokenTransferCheckedInstruction implements TransactionInstruction {
+        programId: Address
         amount: String
         authority: Account
         decimals: BigInt # FIXME:*
@@ -1266,14 +1185,10 @@ var instructionTypeDefs = (
         source: Account
         tokenAmount: String
     }
-    type SplTokenTransferCheckedInstruction implements TransactionInstruction {
-        data: SplTokenTransferCheckedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: ApproveChecked
-    type SplTokenApproveCheckedInstructionData {
+    type SplTokenApproveCheckedInstruction implements TransactionInstruction {
+        programId: Address
         delegate: Account
         mint: Account
         multisigOwner: Account
@@ -1281,14 +1196,10 @@ var instructionTypeDefs = (
         source: Account
         tokenAmount: String
     }
-    type SplTokenApproveCheckedInstruction implements TransactionInstruction {
-        data: SplTokenApproveCheckedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: MintToChecked
-    type SplTokenMintToCheckedInstructionData {
+    type SplTokenMintToCheckedInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         authority: Account
         mint: Account
@@ -1296,89 +1207,56 @@ var instructionTypeDefs = (
         multisigMintAuthority: Account
         tokenAmount: String
     }
-    type SplTokenMintToCheckedInstruction implements TransactionInstruction {
-        data: SplTokenMintToCheckedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: BurnChecked
-    type SplTokenBurnCheckedInstructionData {
+    type SplTokenBurnCheckedInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         authority: Account
         mint: Account
         multisigAuthority: Account
         tokenAmount: String
     }
-    type SplTokenBurnCheckedInstruction implements TransactionInstruction {
-        data: SplTokenBurnCheckedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: SyncNative
-    type SplTokenSyncNativeInstructionData {
-        account: Account
-    }
     type SplTokenSyncNativeInstruction implements TransactionInstruction {
-        data: SplTokenSyncNativeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        programId: Address
+        account: Account
     }
 
     # SplToken: GetAccountDataSize
-    type SplTokenGetAccountDataSizeInstructionData {
+    type SplTokenGetAccountDataSizeInstruction implements TransactionInstruction {
+        programId: Address
         extensionTypes: [String]
         mint: Account
     }
-    type SplTokenGetAccountDataSizeInstruction implements TransactionInstruction {
-        data: SplTokenGetAccountDataSizeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: InitializeImmutableOwner
-    type SplTokenInitializeImmutableOwnerInstructionData {
-        account: Account
-    }
     type SplTokenInitializeImmutableOwnerInstruction implements TransactionInstruction {
-        data: SplTokenInitializeImmutableOwnerInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        programId: Address
+        account: Account
     }
 
     # SplToken: AmountToUiAmount
-    type SplTokenAmountToUiAmountInstructionData {
+    type SplTokenAmountToUiAmountInstruction implements TransactionInstruction {
+        programId: Address
         amount: String
         mint: Account
     }
-    type SplTokenAmountToUiAmountInstruction implements TransactionInstruction {
-        data: SplTokenAmountToUiAmountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: UiAmountToAmount
-    type SplTokenUiAmountToAmountInstructionData {
+    type SplTokenUiAmountToAmountInstruction implements TransactionInstruction {
+        programId: Address
         mint: Account
         uiAmount: String
     }
-    type SplTokenUiAmountToAmountInstruction implements TransactionInstruction {
-        data: SplTokenUiAmountToAmountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # SplToken: InitializeMintCloseAuthority
-    type SplTokenInitializeMintCloseAuthorityInstructionData {
+    type SplTokenInitializeMintCloseAuthorityInstruction implements TransactionInstruction {
+        programId: Address
         mint: Account
         newAuthority: Account
     }
-    type SplTokenInitializeMintCloseAuthorityInstruction implements TransactionInstruction {
-        data: SplTokenInitializeMintCloseAuthorityInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # TODO: Extensions!
     # - TransferFeeExtension
@@ -1407,441 +1285,317 @@ var instructionTypeDefs = (
         staker: Account
         withdrawer: Account
     }
-    type StakeInitializeInstructionData {
+    type StakeInitializeInstruction implements TransactionInstruction {
+        programId: Address
         authorized: StakeInitializeInstructionDataAuthorized
         lockup: Lockup
-        rentSysvar: String
+        rentSysvar: Address
         stakeAccount: Account
     }
-    type StakeInitializeInstruction implements TransactionInstruction {
-        data: StakeInitializeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: Authorize
-    type StakeAuthorizeInstructionData {
+    type StakeAuthorizeInstruction implements TransactionInstruction {
+        programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: String
+        clockSysvar: Address
         custodian: Account
         newAuthority: Account
         stakeAccount: Account
     }
-    type StakeAuthorizeInstruction implements TransactionInstruction {
-        data: StakeAuthorizeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: DelegateStake
-    type StakeDelegateStakeInstructionData {
-        clockSysvar: String
+    type StakeDelegateStakeInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
         stakeAccount: Account
         stakeAuthority: Account
         stakeConfigAccount: Account
-        stakeHistorySysvar: String
+        stakeHistorySysvar: Address
         voteAccount: Account
     }
-    type StakeDelegateStakeInstruction implements TransactionInstruction {
-        data: StakeDelegateStakeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: Split
-    type StakeSplitInstructionData {
+    type StakeSplitInstruction implements TransactionInstruction {
+        programId: Address
         lamports: BigInt
         newSplitAccount: Account
         stakeAccount: Account
         stakeAuthority: Account
     }
-    type StakeSplitInstruction implements TransactionInstruction {
-        data: StakeSplitInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: Withdraw
-    type StakeWithdrawInstructionData {
-        clockSysvar: String
+    type StakeWithdrawInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
         destination: Account
         lamports: BigInt
         stakeAccount: Account
         withdrawAuthority: Account
     }
-    type StakeWithdrawInstruction implements TransactionInstruction {
-        data: StakeWithdrawInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: Deactivate
-    type StakeDeactivateInstructionData {
-        clockSysvar: String
+    type StakeDeactivateInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
         stakeAccount: Account
         stakeAuthority: Account
     }
-    type StakeDeactivateInstruction implements TransactionInstruction {
-        data: StakeDeactivateInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: SetLockup
-    type StakeSetLockupInstructionData {
+    type StakeSetLockupInstruction implements TransactionInstruction {
+        programId: Address
         custodian: Account
         lockup: Lockup
         stakeAccount: Account
     }
-    type StakeSetLockupInstruction implements TransactionInstruction {
-        data: StakeSetLockupInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: Merge
-    type StakeMergeInstructionData {
-        clockSysvar: String
+    type StakeMergeInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
         destination: Account
         source: Account
         stakeAuthority: Account
-        stakeHistorySysvar: String
-    }
-    type StakeMergeInstruction implements TransactionInstruction {
-        data: StakeMergeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        stakeHistorySysvar: Address
     }
 
     # Stake: AuthorizeWithSeed
-    type StakeAuthorizeWithSeedInstructionData {
+    type StakeAuthorizeWithSeedInstruction implements TransactionInstruction {
+        programId: Address
         authorityBase: Account
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: String
+        clockSysvar: Address
         custodian: Account
         newAuthorized: Account
         stakeAccount: Account
     }
-    type StakeAuthorizeWithSeedInstruction implements TransactionInstruction {
-        data: StakeAuthorizeWithSeedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: InitializeChecked
     type StakeInitializeCheckedInstructionDataAuthorized {
-        rentSysvar: String
-        stakeAccount: Account
         staker: Account
         withdrawer: Account
     }
     type StakeInitializeCheckedInstruction implements TransactionInstruction {
-        data: StakeInitializeCheckedInstructionDataAuthorized
-        meta: JsonParsedInstructionMeta
-        programId: String
+        programId: Address
+        authorized: StakeInitializeCheckedInstructionDataAuthorized
+        lockup: Lockup
+        rentSysvar: Address
+        stakeAccount: Account
     }
 
     # Stake: AuthorizeChecked
-    type StakeAuthorizeCheckedInstructionData {
+    type StakeAuthorizeCheckedInstruction implements TransactionInstruction {
+        programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: String
+        clockSysvar: Address
         custodian: Account
         newAuthority: Account
         stakeAccount: Account
     }
-    type StakeAuthorizeCheckedInstruction implements TransactionInstruction {
-        data: StakeAuthorizeCheckedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: AuthorizeCheckedWithSeed
-    type StakeAuthorizeCheckedWithSeedInstructionData {
+    type StakeAuthorizeCheckedWithSeedInstruction implements TransactionInstruction {
+        programId: Address
         authorityBase: Account
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: String
+        clockSysvar: Address
         custodian: Account
         newAuthorized: Account
         stakeAccount: Account
     }
-    type StakeAuthorizeCheckedWithSeedInstruction implements TransactionInstruction {
-        data: StakeAuthorizeCheckedWithSeedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: SetLockupChecked
-    type StakeSetLockupCheckedInstructionData {
+    type StakeSetLockupCheckedInstruction implements TransactionInstruction {
+        programId: Address
         custodian: Account
         lockup: Lockup
         stakeAccount: Account
     }
-    type StakeSetLockupCheckedInstruction implements TransactionInstruction {
-        data: StakeSetLockupCheckedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: DeactivateDelinquent
-    type StakeDeactivateDelinquentInstructionData {
+    type StakeDeactivateDelinquentInstruction implements TransactionInstruction {
+        programId: Address
         referenceVoteAccount: Account
         stakeAccount: Account
         voteAccount: Account
     }
-    type StakeDeactivateDelinquentInstruction implements TransactionInstruction {
-        data: StakeDeactivateDelinquentInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Stake: Redelegate
-    type StakeRedelegateInstructionData {
+    type StakeRedelegateInstruction implements TransactionInstruction {
+        programId: Address
         newStakeAccount: Account
         stakeAccount: Account
         stakeAuthority: Account
         stakeConfigAccount: Account
         voteAccount: Account
     }
-    type StakeRedelegateInstruction implements TransactionInstruction {
-        data: StakeRedelegateInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: CreateAccount
-    type CreateAccountInstructionData {
+    type CreateAccountInstruction implements TransactionInstruction {
+        programId: Address
         lamports: BigInt
         newAccount: Account
         owner: Account
         source: Account
         space: BigInt
     }
-    type CreateAccountInstruction implements TransactionInstruction {
-        data: CreateAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: Assign
-    type AssignInstructionData {
+    type AssignInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         owner: Account
     }
-    type AssignInstruction implements TransactionInstruction {
-        data: AssignInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: Transfer
-    type TransferInstructionData {
+    type TransferInstruction implements TransactionInstruction {
+        programId: Address
         destination: Account
         lamports: BigInt
         source: Account
     }
-    type TransferInstruction implements TransactionInstruction {
-        data: TransferInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: CreateAccountWithSeed
-    type CreateAccountWithSeedInstructionData {
+    type CreateAccountWithSeedInstruction implements TransactionInstruction {
+        programId: Address
         base: Account
         lamports: BigInt
         owner: Account
         seed: String
         space: BigInt
     }
-    type CreateAccountWithSeedInstruction implements TransactionInstruction {
-        data: CreateAccountWithSeedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: AdvanceNonceAccount
-    type AdvanceNonceAccountInstructionData {
+    type AdvanceNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
         nonceAccount: Account
         nonceAuthority: Account
-        recentBlockhashesSysvar: String
-    }
-    type AdvanceNonceAccountInstruction implements TransactionInstruction {
-        data: AdvanceNonceAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        recentBlockhashesSysvar: Address
     }
 
     # System: WithdrawNonceAccount
-    type WithdrawNonceAccountInstructionData {
+    type WithdrawNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
         destination: Account
         lamports: BigInt
         nonceAccount: Account
         nonceAuthority: Account
-        recentBlockhashesSysvar: String
-        rentSysvar: String
-    }
-    type WithdrawNonceAccountInstruction implements TransactionInstruction {
-        data: WithdrawNonceAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        recentBlockhashesSysvar: Address
+        rentSysvar: Address
     }
 
     # System: InitializeNonceAccount
-    type InitializeNonceAccountInstructionData {
+    type InitializeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
         nonceAccount: Account
         nonceAuthority: Account
-        recentBlockhashesSysvar: String
-        rentSysvar: String
-    }
-    type InitializeNonceAccountInstruction implements TransactionInstruction {
-        data: InitializeNonceAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
+        recentBlockhashesSysvar: Address
+        rentSysvar: Address
     }
 
     # System: AuthorizeNonceAccount
-    type AuthorizeNonceAccountInstructionData {
+    type AuthorizeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
         newAuthorized: Account
         nonceAccount: Account
         nonceAuthority: Account
     }
-    type AuthorizeNonceAccountInstruction implements TransactionInstruction {
-        data: AuthorizeNonceAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: UpgradeNonceAccount
-    type UpgradeNonceAccountInstructionData {
+    type UpgradeNonceAccountInstruction implements TransactionInstruction {
+        programId: Address
         nonceAccount: Account
         nonceAuthority: Account
     }
-    type UpgradeNonceAccountInstruction implements TransactionInstruction {
-        data: UpgradeNonceAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: Allocate
-    type AllocateInstructionData {
+    type AllocateInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
         space: BigInt
     }
-    type AllocateInstruction implements TransactionInstruction {
-        data: AllocateInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: AllocateWithSeed
-    type AllocateWithSeedInstructionData {
+    type AllocateWithSeedInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
-        base: String
+        base: Address
         owner: Account
         seed: String
         space: BigInt
     }
-    type AllocateWithSeedInstruction implements TransactionInstruction {
-        data: AllocateWithSeedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: AssignWithSeed
-    type AssignWithSeedInstructionData {
+    type AssignWithSeedInstruction implements TransactionInstruction {
+        programId: Address
         account: Account
-        base: String
+        base: Address
         owner: Account
         seed: String
     }
-    type AssignWithSeedInstruction implements TransactionInstruction {
-        data: AssignWithSeedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # System: TransferWithSeed
-    type TransferWithSeedInstructionData {
+    type TransferWithSeedInstruction implements TransactionInstruction {
+        programId: Address
         destination: Account
         lamports: BigInt
         source: Account
-        sourceBase: String
+        sourceBase: Address
         sourceOwner: Account
         sourceSeed: String
     }
-    type TransferWithSeedInstruction implements TransactionInstruction {
-        data: TransferWithSeedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: InitializeAccount
-    type VoteInitializeAccountInstructionData {
+    type VoteInitializeAccountInstruction implements TransactionInstruction {
+        programId: Address
         authorizedVoter: Account
         authorizedWithdrawer: Account
-        clockSysvar: String
+        clockSysvar: Address
         commission: BigInt # FIXME:*
         node: Account
-        rentSysvar: String
+        rentSysvar: Address
         voteAccount: Account
     }
-    type VoteInitializeAccountInstruction implements TransactionInstruction {
-        data: VoteInitializeAccountInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: Authorize
-    type VoteAuthorizeInstructionData {
+    type VoteAuthorizeInstruction implements TransactionInstruction {
+        programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: String
+        clockSysvar: Address
         newAuthority: Account
         voteAccount: Account
     }
-    type VoteAuthorizeInstruction implements TransactionInstruction {
-        data: VoteAuthorizeInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: AuthorizeWithSeed
-    type VoteAuthorizeWithSeedInstructionData {
+    type VoteAuthorizeWithSeedInstruction implements TransactionInstruction {
+        programId: Address
         authorityBaseKey: String
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: String
+        clockSysvar: Address
         newAuthority: Account
         voteAccount: Account
     }
-    type VoteAuthorizeWithSeedInstruction implements TransactionInstruction {
-        data: VoteAuthorizeWithSeedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: AuthorizeCheckedWithSeed
-    type VoteAuthorizeCheckedWithSeedInstructionData {
+    type VoteAuthorizeCheckedWithSeedInstruction implements TransactionInstruction {
+        programId: Address
         authorityBaseKey: String
         authorityOwner: Account
         authoritySeed: String
         authorityType: String
-        clockSysvar: String
+        clockSysvar: Address
         newAuthority: Account
         voteAccount: Account
     }
-    type VoteAuthorizeCheckedWithSeedInstruction implements TransactionInstruction {
-        data: VoteAuthorizeCheckedWithSeedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     type Vote {
         hash: String
@@ -1850,18 +1604,14 @@ var instructionTypeDefs = (
     }
 
     # Vote: Vote
-    type VoteVoteInstructionData {
-        clockSysvar: String
-        slotHashesSysvar: String
+    type VoteVoteInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
+        slotHashesSysvar: Address
         vote: Vote
         voteAccount: Account
         voteAuthority: Account
     }
-    type VoteVoteInstruction implements TransactionInstruction {
-        data: VoteVoteInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     type VoteStateUpdateLockout {
         confirmationCount: BigInt # FIXME:*
@@ -1875,402 +1625,366 @@ var instructionTypeDefs = (
     }
 
     # Vote: UpdateVoteState
-    type VoteUpdateVoteStateInstructionData {
+    type VoteUpdateVoteStateInstruction implements TransactionInstruction {
+        programId: Address
         hash: String
         voteAccount: Account
         voteAuthority: Account
         voteStateUpdate: VoteStateUpdate
     }
-    type VoteUpdateVoteStateInstruction implements TransactionInstruction {
-        data: VoteUpdateVoteStateInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: UpdateVoteStateSwitch
-    type VoteUpdateVoteStateSwitchInstructionData {
+    type VoteUpdateVoteStateSwitchInstruction implements TransactionInstruction {
+        programId: Address
         hash: String
         voteAccount: Account
         voteAuthority: Account
         voteStateUpdate: VoteStateUpdate
     }
-    type VoteUpdateVoteStateSwitchInstruction implements TransactionInstruction {
-        data: VoteUpdateVoteStateSwitchInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: CompactUpdateVoteState
-    type VoteCompactUpdateVoteStateInstructionData {
+    type VoteCompactUpdateVoteStateInstruction implements TransactionInstruction {
+        programId: Address
         hash: String
         voteAccount: Account
         voteAuthority: Account
         voteStateUpdate: VoteStateUpdate
     }
-    type VoteCompactUpdateVoteStateInstruction implements TransactionInstruction {
-        data: VoteCompactUpdateVoteStateInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: CompactUpdateVoteStateSwitch
-    type VoteCompactUpdateVoteStateSwitchInstructionData {
+    type VoteCompactUpdateVoteStateSwitchInstruction implements TransactionInstruction {
+        programId: Address
         hash: String
         voteAccount: Account
         voteAuthority: Account
         voteStateUpdate: VoteStateUpdate
     }
-    type VoteCompactUpdateVoteStateSwitchInstruction implements TransactionInstruction {
-        data: VoteCompactUpdateVoteStateSwitchInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: Withdraw
-    type VoteWithdrawInstructionData {
+    type VoteWithdrawInstruction implements TransactionInstruction {
+        programId: Address
         destination: Account
         lamports: BigInt
         voteAccount: Account
         withdrawAuthority: Account
     }
-    type VoteWithdrawInstruction implements TransactionInstruction {
-        data: VoteWithdrawInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: UpdateValidatorIdentity
-    type VoteUpdateValidatorIdentityInstructionData {
+    type VoteUpdateValidatorIdentityInstruction implements TransactionInstruction {
+        programId: Address
         newValidatorIdentity: Account
         voteAccount: Account
         withdrawAuthority: Account
     }
-    type VoteUpdateValidatorIdentityInstruction implements TransactionInstruction {
-        data: VoteUpdateValidatorIdentityInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: UpdateCommission
-    type VoteUpdateCommissionInstructionData {
+    type VoteUpdateCommissionInstruction implements TransactionInstruction {
+        programId: Address
         commission: BigInt # FIXME:*
         voteAccount: Account
         withdrawAuthority: Account
     }
-    type VoteUpdateCommissionInstruction implements TransactionInstruction {
-        data: VoteUpdateCommissionInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: VoteSwitch
-    type VoteVoteSwitchInstructionData {
-        clockSysvar: String
+    type VoteVoteSwitchInstruction implements TransactionInstruction {
+        programId: Address
+        clockSysvar: Address
         hash: String
-        slotHashesSysvar: String
+        slotHashesSysvar: Address
         vote: Vote
         voteAccount: Account
         voteAuthority: Account
     }
-    type VoteVoteSwitchInstruction implements TransactionInstruction {
-        data: VoteVoteSwitchInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 
     # Vote: AuthorizeChecked
-    type VoteAuthorizeCheckedInstructionData {
+    type VoteAuthorizeCheckedInstruction implements TransactionInstruction {
+        programId: Address
         authority: Account
         authorityType: String
-        clockSysvar: String
+        clockSysvar: Address
         newAuthority: Account
         voteAccount: Account
     }
-    type VoteAuthorizeCheckedInstruction implements TransactionInstruction {
-        data: VoteAuthorizeCheckedInstructionData
-        meta: JsonParsedInstructionMeta
-        programId: String
-    }
 `
 );
 var instructionResolvers = {
   TransactionInstruction: {
     __resolveType(instruction) {
-      if (instruction.meta) {
-        if (instruction.meta.program === "address-lookup-table") {
-          if (instruction.meta.type === "createLookupTable") {
+      if (instruction.programName) {
+        if (instruction.programName === "address-lookup-table") {
+          if (instruction.instructionType === "createLookupTable") {
             return "CreateLookupTableInstruction";
           }
-          if (instruction.meta.type === "freezeLookupTable") {
+          if (instruction.instructionType === "freezeLookupTable") {
             return "FreezeLookupTableInstruction";
           }
-          if (instruction.meta.type === "extendLookupTable") {
+          if (instruction.instructionType === "extendLookupTable") {
             return "ExtendLookupTableInstruction";
           }
-          if (instruction.meta.type === "deactivateLookupTable") {
+          if (instruction.instructionType === "deactivateLookupTable") {
             return "DeactivateLookupTableInstruction";
           }
-          if (instruction.meta.type === "closeLookupTable") {
+          if (instruction.instructionType === "closeLookupTable") {
             return "CloseLookupTableInstruction";
           }
         }
-        if (instruction.meta.program === "bpf-loader") {
-          if (instruction.meta.type === "write") {
+        if (instruction.programName === "bpf-loader") {
+          if (instruction.instructionType === "write") {
             return "BpfLoaderWriteInstruction";
           }
-          if (instruction.meta.type === "finalize") {
+          if (instruction.instructionType === "finalize") {
             return "BpfLoaderFinalizeInstruction";
           }
         }
-        if (instruction.meta.program === "bpf-upgradeable-loader") {
-          if (instruction.meta.type === "initializeBuffer") {
+        if (instruction.programName === "bpf-upgradeable-loader") {
+          if (instruction.instructionType === "initializeBuffer") {
             return "BpfUpgradeableLoaderInitializeBufferInstruction";
           }
-          if (instruction.meta.type === "write") {
+          if (instruction.instructionType === "write") {
             return "BpfUpgradeableLoaderWriteInstruction";
           }
-          if (instruction.meta.type === "deployWithMaxDataLen") {
+          if (instruction.instructionType === "deployWithMaxDataLen") {
             return "BpfUpgradeableLoaderDeployWithMaxDataLenInstruction";
           }
-          if (instruction.meta.type === "upgrade") {
+          if (instruction.instructionType === "upgrade") {
             return "BpfUpgradeableLoaderUpgradeInstruction";
           }
-          if (instruction.meta.type === "setAuthority") {
+          if (instruction.instructionType === "setAuthority") {
             return "BpfUpgradeableLoaderSetAuthorityInstruction";
           }
-          if (instruction.meta.type === "setAuthorityChecked") {
+          if (instruction.instructionType === "setAuthorityChecked") {
             return "BpfUpgradeableLoaderSetAuthorityCheckedInstruction";
           }
-          if (instruction.meta.type === "close") {
+          if (instruction.instructionType === "close") {
             return "BpfUpgradeableLoaderCloseInstruction";
           }
-          if (instruction.meta.type === "extendProgram") {
+          if (instruction.instructionType === "extendProgram") {
             return "BpfUpgradeableLoaderExtendProgramInstruction";
           }
         }
-        if (instruction.meta.program === "spl-associated-token-account") {
-          if (instruction.meta.type === "create") {
+        if (instruction.programName === "spl-associated-token-account") {
+          if (instruction.instructionType === "create") {
             return "SplAssociatedTokenCreateInstruction";
           }
-          if (instruction.meta.type === "createIdempotent") {
+          if (instruction.instructionType === "createIdempotent") {
             return "SplAssociatedTokenCreateIdempotentInstruction";
           }
-          if (instruction.meta.type === "recoverNested") {
+          if (instruction.instructionType === "recoverNested") {
             return "SplAssociatedTokenRecoverNestedInstruction";
           }
         }
-        if (instruction.meta.program === "spl-memo") {
+        if (instruction.programName === "spl-memo") {
           return "SplMemoInstruction";
         }
-        if (instruction.meta.program === "spl-token") {
-          if (instruction.meta.type === "initializeMint") {
+        if (instruction.programName === "spl-token") {
+          if (instruction.instructionType === "initializeMint") {
             return "SplTokenInitializeMintInstruction";
           }
-          if (instruction.meta.type === "initializeMint2") {
+          if (instruction.instructionType === "initializeMint2") {
             return "SplTokenInitializeMint2Instruction";
           }
-          if (instruction.meta.type === "initializeAccount") {
+          if (instruction.instructionType === "initializeAccount") {
             return "SplTokenInitializeAccountInstruction";
           }
-          if (instruction.meta.type === "initializeAccount2") {
+          if (instruction.instructionType === "initializeAccount2") {
             return "SplTokenInitializeAccount2Instruction";
           }
-          if (instruction.meta.type === "initializeAccount3") {
+          if (instruction.instructionType === "initializeAccount3") {
             return "SplTokenInitializeAccount3Instruction";
           }
-          if (instruction.meta.type === "initializeMultisig") {
+          if (instruction.instructionType === "initializeMultisig") {
             return "SplTokenInitializeMultisigInstruction";
           }
-          if (instruction.meta.type === "initializeMultisig2") {
+          if (instruction.instructionType === "initializeMultisig2") {
             return "SplTokenInitializeMultisig2Instruction";
           }
-          if (instruction.meta.type === "transfer") {
+          if (instruction.instructionType === "transfer") {
             return "SplTokenTransferInstruction";
           }
-          if (instruction.meta.type === "approve") {
+          if (instruction.instructionType === "approve") {
             return "SplTokenApproveInstruction";
           }
-          if (instruction.meta.type === "revoke") {
+          if (instruction.instructionType === "revoke") {
             return "SplTokenRevokeInstruction";
           }
-          if (instruction.meta.type === "setAuthority") {
+          if (instruction.instructionType === "setAuthority") {
             return "SplTokenSetAuthorityInstruction";
           }
-          if (instruction.meta.type === "mintTo") {
+          if (instruction.instructionType === "mintTo") {
             return "SplTokenMintToInstruction";
           }
-          if (instruction.meta.type === "burn") {
+          if (instruction.instructionType === "burn") {
             return "SplTokenBurnInstruction";
           }
-          if (instruction.meta.type === "closeAccount") {
+          if (instruction.instructionType === "closeAccount") {
             return "SplTokenCloseAccountInstruction";
           }
-          if (instruction.meta.type === "freezeAccount") {
+          if (instruction.instructionType === "freezeAccount") {
             return "SplTokenFreezeAccountInstruction";
           }
-          if (instruction.meta.type === "thawAccount") {
+          if (instruction.instructionType === "thawAccount") {
             return "SplTokenThawAccountInstruction";
           }
-          if (instruction.meta.type === "transferChecked") {
+          if (instruction.instructionType === "transferChecked") {
             return "SplTokenTransferCheckedInstruction";
           }
-          if (instruction.meta.type === "approveChecked") {
+          if (instruction.instructionType === "approveChecked") {
             return "SplTokenApproveCheckedInstruction";
           }
-          if (instruction.meta.type === "mintToChecked") {
+          if (instruction.instructionType === "mintToChecked") {
             return "SplTokenMintToCheckedInstruction";
           }
-          if (instruction.meta.type === "burnChecked") {
+          if (instruction.instructionType === "burnChecked") {
             return "SplTokenBurnCheckedInstruction";
           }
-          if (instruction.meta.type === "syncNative") {
+          if (instruction.instructionType === "syncNative") {
             return "SplTokenSyncNativeInstruction";
           }
-          if (instruction.meta.type === "getAccountDataSize") {
+          if (instruction.instructionType === "getAccountDataSize") {
             return "SplTokenGetAccountDataSizeInstruction";
           }
-          if (instruction.meta.type === "initializeImmutableOwner") {
+          if (instruction.instructionType === "initializeImmutableOwner") {
             return "SplTokenInitializeImmutableOwnerInstruction";
           }
-          if (instruction.meta.type === "amountToUiAmount") {
+          if (instruction.instructionType === "amountToUiAmount") {
             return "SplTokenAmountToUiAmountInstruction";
           }
-          if (instruction.meta.type === "uiAmountToAmount") {
+          if (instruction.instructionType === "uiAmountToAmount") {
             return "SplTokenUiAmountToAmountInstruction";
           }
-          if (instruction.meta.type === "initializeMintCloseAuthority") {
+          if (instruction.instructionType === "initializeMintCloseAuthority") {
             return "SplTokenInitializeMintCloseAuthorityInstruction";
           }
         }
-        if (instruction.meta.program === "stake") {
-          if (instruction.meta.type === "initialize") {
+        if (instruction.programName === "stake") {
+          if (instruction.instructionType === "initialize") {
             return "StakeInitializeInstruction";
           }
-          if (instruction.meta.type === "authorize") {
+          if (instruction.instructionType === "authorize") {
             return "StakeAuthorizeInstruction";
           }
-          if (instruction.meta.type === "delegate") {
+          if (instruction.instructionType === "delegate") {
             return "StakeDelegateStakeInstruction";
           }
-          if (instruction.meta.type === "split") {
+          if (instruction.instructionType === "split") {
             return "StakeSplitInstruction";
           }
-          if (instruction.meta.type === "withdraw") {
+          if (instruction.instructionType === "withdraw") {
             return "StakeWithdrawInstruction";
           }
-          if (instruction.meta.type === "deactivate") {
+          if (instruction.instructionType === "deactivate") {
             return "StakeDeactivateInstruction";
           }
-          if (instruction.meta.type === "setLockup") {
+          if (instruction.instructionType === "setLockup") {
             return "StakeSetLockupInstruction";
           }
-          if (instruction.meta.type === "merge") {
+          if (instruction.instructionType === "merge") {
             return "StakeMergeInstruction";
           }
-          if (instruction.meta.type === "authorizeWithSeed") {
+          if (instruction.instructionType === "authorizeWithSeed") {
             return "StakeAuthorizeWithSeedInstruction";
           }
-          if (instruction.meta.type === "initializeChecked") {
+          if (instruction.instructionType === "initializeChecked") {
             return "StakeInitializeCheckedInstruction";
           }
-          if (instruction.meta.type === "authorizeChecked") {
+          if (instruction.instructionType === "authorizeChecked") {
             return "StakeAuthorizeCheckedInstruction";
           }
-          if (instruction.meta.type === "authorizeCheckedWithSeed") {
+          if (instruction.instructionType === "authorizeCheckedWithSeed") {
             return "StakeAuthorizeCheckedWithSeedInstruction";
           }
-          if (instruction.meta.type === "setLockupChecked") {
+          if (instruction.instructionType === "setLockupChecked") {
             return "StakeSetLockupCheckedInstruction";
           }
-          if (instruction.meta.type === "deactivateDelinquent") {
+          if (instruction.instructionType === "deactivateDelinquent") {
             return "StakeDeactivateDelinquentInstruction";
           }
-          if (instruction.meta.type === "redelegate") {
+          if (instruction.instructionType === "redelegate") {
             return "StakeRedelegateInstruction";
           }
         }
-        if (instruction.meta.program === "system") {
-          if (instruction.meta.type === "createAccount") {
+        if (instruction.programName === "system") {
+          if (instruction.instructionType === "createAccount") {
             return "CreateAccountInstruction";
           }
-          if (instruction.meta.type === "assign") {
+          if (instruction.instructionType === "assign") {
             return "AssignInstruction";
           }
-          if (instruction.meta.type === "transfer") {
+          if (instruction.instructionType === "transfer") {
             return "TransferInstruction";
           }
-          if (instruction.meta.type === "createAccountWithSeed") {
+          if (instruction.instructionType === "createAccountWithSeed") {
             return "CreateAccountWithSeedInstruction";
           }
-          if (instruction.meta.type === "advanceNonceAccount") {
+          if (instruction.instructionType === "advanceNonceAccount") {
             return "AdvanceNonceAccountInstruction";
           }
-          if (instruction.meta.type === "withdrawNonceAccount") {
+          if (instruction.instructionType === "withdrawNonceAccount") {
             return "WithdrawNonceAccountInstruction";
           }
-          if (instruction.meta.type === "initializeNonceAccount") {
+          if (instruction.instructionType === "initializeNonceAccount") {
             return "InitializeNonceAccountInstruction";
           }
-          if (instruction.meta.type === "authorizeNonceAccount") {
+          if (instruction.instructionType === "authorizeNonceAccount") {
             return "AuthorizeNonceAccountInstruction";
           }
-          if (instruction.meta.type === "upgradeNonceAccount") {
+          if (instruction.instructionType === "upgradeNonceAccount") {
             return "UpgradeNonceAccountInstruction";
           }
-          if (instruction.meta.type === "allocate") {
+          if (instruction.instructionType === "allocate") {
             return "AllocateInstruction";
           }
-          if (instruction.meta.type === "allocateWithSeed") {
+          if (instruction.instructionType === "allocateWithSeed") {
             return "AllocateWithSeedInstruction";
           }
-          if (instruction.meta.type === "assignWithSeed") {
+          if (instruction.instructionType === "assignWithSeed") {
             return "AssignWithSeedInstruction";
           }
-          if (instruction.meta.type === "transferWithSeed") {
+          if (instruction.instructionType === "transferWithSeed") {
             return "TransferWithSeedInstruction";
           }
         }
-        if (instruction.meta.program === "vote") {
-          if (instruction.meta.type === "initialize") {
+        if (instruction.programName === "vote") {
+          if (instruction.instructionType === "initialize") {
             return "VoteInitializeAccountInstruction";
           }
-          if (instruction.meta.type === "authorize") {
+          if (instruction.instructionType === "authorize") {
             return "VoteAuthorizeInstruction";
           }
-          if (instruction.meta.type === "authorizeWithSeed") {
+          if (instruction.instructionType === "authorizeWithSeed") {
             return "VoteAuthorizeWithSeedInstruction";
           }
-          if (instruction.meta.type === "authorizeCheckedWithSeed") {
+          if (instruction.instructionType === "authorizeCheckedWithSeed") {
             return "VoteAuthorizeCheckedWithSeedInstruction";
           }
-          if (instruction.meta.type === "vote") {
+          if (instruction.instructionType === "vote") {
             return "VoteVoteInstruction";
           }
-          if (instruction.meta.type === "updatevotestate") {
+          if (instruction.instructionType === "updatevotestate") {
             return "VoteUpdateVoteStateInstruction";
           }
-          if (instruction.meta.type === "updatevotestateswitch") {
+          if (instruction.instructionType === "updatevotestateswitch") {
             return "VoteUpdateVoteStateSwitchInstruction";
           }
-          if (instruction.meta.type === "compactupdatevotestate") {
+          if (instruction.instructionType === "compactupdatevotestate") {
             return "VoteCompactUpdateVoteStateInstruction";
           }
-          if (instruction.meta.type === "compactupdatevotestateswitch") {
+          if (instruction.instructionType === "compactupdatevotestateswitch") {
             return "VoteCompactUpdateVoteStateSwitchInstruction";
           }
-          if (instruction.meta.type === "withdraw") {
+          if (instruction.instructionType === "withdraw") {
             return "VoteWithdrawInstruction";
           }
-          if (instruction.meta.type === "updateValidatorIdentity") {
+          if (instruction.instructionType === "updateValidatorIdentity") {
             return "VoteUpdateValidatorIdentityInstruction";
           }
-          if (instruction.meta.type === "updateCommission") {
+          if (instruction.instructionType === "updateCommission") {
             return "VoteUpdateCommissionInstruction";
           }
-          if (instruction.meta.type === "voteSwitch") {
+          if (instruction.instructionType === "voteSwitch") {
             return "VoteVoteSwitchInstruction";
           }
-          if (instruction.meta.type === "authorizeChecked") {
+          if (instruction.instructionType === "authorizeChecked") {
             return "VoteAuthorizeCheckedInstruction";
           }
         }
@@ -2278,80 +1992,80 @@ var instructionResolvers = {
       return "GenericInstruction";
     }
   },
-  CreateLookupTableInstructionData: {
+  CreateLookupTableInstruction: {
     lookupTableAccount: resolveAccount("lookupTableAccount"),
     lookupTableAuthority: resolveAccount("lookupTableAuthority"),
     payerAccount: resolveAccount("payerAccount"),
     systemProgram: resolveAccount("systemProgram")
   },
-  ExtendLookupTableInstructionData: {
+  ExtendLookupTableInstruction: {
     lookupTableAccount: resolveAccount("lookupTableAccount"),
     lookupTableAuthority: resolveAccount("lookupTableAuthority"),
     payerAccount: resolveAccount("payerAccount"),
     systemProgram: resolveAccount("systemProgram")
   },
-  FreezeLookupTableInstructionData: {
+  FreezeLookupTableInstruction: {
     lookupTableAccount: resolveAccount("lookupTableAccount"),
     lookupTableAuthority: resolveAccount("lookupTableAuthority")
   },
-  DeactivateLookupTableInstructionData: {
+  DeactivateLookupTableInstruction: {
     lookupTableAccount: resolveAccount("lookupTableAccount"),
     lookupTableAuthority: resolveAccount("lookupTableAuthority")
   },
-  CloseLookupTableInstructionData: {
+  CloseLookupTableInstruction: {
     lookupTableAccount: resolveAccount("lookupTableAccount"),
     lookupTableAuthority: resolveAccount("lookupTableAuthority"),
     recipient: resolveAccount("recipient")
   },
-  BpfLoaderWriteInstructionData: {
+  BpfLoaderWriteInstruction: {
     account: resolveAccount("account")
   },
-  BpfLoaderFinalizeInstructionData: {
+  BpfLoaderFinalizeInstruction: {
     account: resolveAccount("account")
   },
-  BpfUpgradeableLoaderInitializeBufferInstructionData: {
+  BpfUpgradeableLoaderInitializeBufferInstruction: {
     account: resolveAccount("account")
   },
-  BpfUpgradeableLoaderWriteInstructionData: {
+  BpfUpgradeableLoaderWriteInstruction: {
     account: resolveAccount("account"),
     authority: resolveAccount("authority")
   },
-  BpfUpgradeableLoaderDeployWithMaxDataLenInstructionData: {
+  BpfUpgradeableLoaderDeployWithMaxDataLenInstruction: {
     authority: resolveAccount("authority"),
     bufferAccount: resolveAccount("bufferAccount"),
     payerAccount: resolveAccount("payerAccount"),
     programAccount: resolveAccount("programAccount"),
     programDataAccount: resolveAccount("programDataAccount")
   },
-  BpfUpgradeableLoaderUpgradeInstructionData: {
+  BpfUpgradeableLoaderUpgradeInstruction: {
     authority: resolveAccount("authority"),
     bufferAccount: resolveAccount("bufferAccount"),
     programAccount: resolveAccount("programAccount"),
     programDataAccount: resolveAccount("programDataAccount")
   },
-  BpfUpgradeableLoaderSetAuthorityInstructionData: {
+  BpfUpgradeableLoaderSetAuthorityInstruction: {
     account: resolveAccount("account"),
     authority: resolveAccount("authority"),
     newAuthority: resolveAccount("newAuthority")
   },
-  BpfUpgradeableLoaderSetAuthorityCheckedInstructionData: {
+  BpfUpgradeableLoaderSetAuthorityCheckedInstruction: {
     account: resolveAccount("account"),
     authority: resolveAccount("authority"),
     newAuthority: resolveAccount("newAuthority")
   },
-  BpfUpgradeableLoaderCloseInstructionData: {
+  BpfUpgradeableLoaderCloseInstruction: {
     account: resolveAccount("account"),
     authority: resolveAccount("authority"),
     programAccount: resolveAccount("programAccount"),
     recipient: resolveAccount("recipient")
   },
-  BpfUpgradeableLoaderExtendProgramInstructionData: {
+  BpfUpgradeableLoaderExtendProgramInstruction: {
     payerAccount: resolveAccount("payerAccount"),
     programAccount: resolveAccount("programAccount"),
     programDataAccount: resolveAccount("programDataAccount"),
     systemProgram: resolveAccount("systemProgram")
   },
-  SplAssociatedTokenCreateInstructionData: {
+  SplAssociatedTokenCreateInstruction: {
     account: resolveAccount("account"),
     mint: resolveAccount("mint"),
     source: resolveAccount("source"),
@@ -2359,7 +2073,7 @@ var instructionResolvers = {
     tokenProgram: resolveAccount("tokenProgram"),
     wallet: resolveAccount("wallet")
   },
-  SplAssociatedTokenCreateIdempotentInstructionData: {
+  SplAssociatedTokenCreateIdempotentInstruction: {
     account: resolveAccount("account"),
     mint: resolveAccount("mint"),
     source: resolveAccount("source"),
@@ -2367,7 +2081,7 @@ var instructionResolvers = {
     tokenProgram: resolveAccount("tokenProgram"),
     wallet: resolveAccount("wallet")
   },
-  SplAssociatedTokenRecoverNestedInstructionData: {
+  SplAssociatedTokenRecoverNestedInstruction: {
     destination: resolveAccount("destination"),
     nestedMint: resolveAccount("nestedMint"),
     nestedOwner: resolveAccount("nestedOwner"),
@@ -2376,130 +2090,130 @@ var instructionResolvers = {
     tokenProgram: resolveAccount("tokenProgram"),
     wallet: resolveAccount("wallet")
   },
-  SplTokenInitializeMintInstructionData: {
+  SplTokenInitializeMintInstruction: {
     freezeAuthority: resolveAccount("freezeAuthority"),
     mint: resolveAccount("mint"),
     mintAuthority: resolveAccount("mintAuthority")
   },
-  SplTokenInitializeMint2InstructionData: {
+  SplTokenInitializeMint2Instruction: {
     freezeAuthority: resolveAccount("freezeAuthority"),
     mint: resolveAccount("mint"),
     mintAuthority: resolveAccount("mintAuthority")
   },
-  SplTokenInitializeAccountInstructionData: {
+  SplTokenInitializeAccountInstruction: {
     account: resolveAccount("account"),
     mint: resolveAccount("mint"),
     owner: resolveAccount("owner")
   },
-  SplTokenInitializeAccount2InstructionData: {
+  SplTokenInitializeAccount2Instruction: {
     account: resolveAccount("account"),
     mint: resolveAccount("mint"),
     owner: resolveAccount("owner")
   },
-  SplTokenInitializeAccount3InstructionData: {
+  SplTokenInitializeAccount3Instruction: {
     account: resolveAccount("account"),
     mint: resolveAccount("mint"),
     owner: resolveAccount("owner")
   },
-  SplTokenInitializeMultisigInstructionData: {
+  SplTokenInitializeMultisigInstruction: {
     multisig: resolveAccount("multisig")
   },
-  SplTokenInitializeMultisig2InstructionData: {
+  SplTokenInitializeMultisig2Instruction: {
     multisig: resolveAccount("multisig")
   },
-  SplTokenTransferInstructionData: {
+  SplTokenTransferInstruction: {
     authority: resolveAccount("authority"),
     destination: resolveAccount("destination"),
     multisigAuthority: resolveAccount("multisigAuthority"),
     source: resolveAccount("source")
   },
-  SplTokenApproveInstructionData: {
+  SplTokenApproveInstruction: {
     delegate: resolveAccount("delegate"),
     multisigOwner: resolveAccount("multisigOwner"),
     owner: resolveAccount("owner"),
     source: resolveAccount("source")
   },
-  SplTokenRevokeInstructionData: {
+  SplTokenRevokeInstruction: {
     multisigOwner: resolveAccount("multisigOwner"),
     owner: resolveAccount("owner"),
     source: resolveAccount("source")
   },
-  SplTokenSetAuthorityInstructionData: {
+  SplTokenSetAuthorityInstruction: {
     authority: resolveAccount("authority"),
     multisigAuthority: resolveAccount("multisigAuthority"),
     newAuthority: resolveAccount("newAuthority")
   },
-  SplTokenMintToInstructionData: {
+  SplTokenMintToInstruction: {
     account: resolveAccount("account"),
     authority: resolveAccount("authority"),
     mint: resolveAccount("mint"),
     mintAuthority: resolveAccount("mintAuthority"),
     multisigMintAuthority: resolveAccount("multisigMintAuthority")
   },
-  SplTokenBurnInstructionData: {
+  SplTokenBurnInstruction: {
     account: resolveAccount("account"),
     authority: resolveAccount("authority"),
     mint: resolveAccount("mint"),
     multisigAuthority: resolveAccount("multisigAuthority")
   },
-  SplTokenCloseAccountInstructionData: {
+  SplTokenCloseAccountInstruction: {
     account: resolveAccount("account"),
     destination: resolveAccount("destination"),
     multisigOwner: resolveAccount("multisigOwner"),
     owner: resolveAccount("owner")
   },
-  SplTokenFreezeAccountInstructionData: {
+  SplTokenFreezeAccountInstruction: {
     account: resolveAccount("account"),
     freezeAuthority: resolveAccount("freezeAuthority"),
     mint: resolveAccount("mint"),
     multisigFreezeAuthority: resolveAccount("multisigFreezeAuthority")
   },
-  SplTokenThawAccountInstructionData: {
+  SplTokenThawAccountInstruction: {
     account: resolveAccount("account"),
     freezeAuthority: resolveAccount("freezeAuthority"),
     mint: resolveAccount("mint"),
     multisigFreezeAuthority: resolveAccount("multisigFreezeAuthority")
   },
-  SplTokenTransferCheckedInstructionData: {
+  SplTokenTransferCheckedInstruction: {
     authority: resolveAccount("authority"),
     destination: resolveAccount("destination"),
     mint: resolveAccount("mint"),
     multisigAuthority: resolveAccount("multisigAuthority"),
     source: resolveAccount("source")
   },
-  SplTokenApproveCheckedInstructionData: {
+  SplTokenApproveCheckedInstruction: {
     delegate: resolveAccount("delegate"),
     mint: resolveAccount("mint"),
     multisigOwner: resolveAccount("multisigOwner"),
     owner: resolveAccount("owner"),
     source: resolveAccount("source")
   },
-  SplTokenMintToCheckedInstructionData: {
+  SplTokenMintToCheckedInstruction: {
     account: resolveAccount("account"),
     authority: resolveAccount("authority"),
     mint: resolveAccount("mint"),
     mintAuthority: resolveAccount("mintAuthority"),
     multisigMintAuthority: resolveAccount("multisigMintAuthority")
   },
-  SplTokenBurnCheckedInstructionData: {
+  SplTokenBurnCheckedInstruction: {
     account: resolveAccount("account"),
     authority: resolveAccount("authority"),
     mint: resolveAccount("mint"),
     multisigAuthority: resolveAccount("multisigAuthority")
   },
-  SplTokenSyncNativeInstructionData: {
+  SplTokenSyncNativeInstruction: {
     account: resolveAccount("account")
   },
-  SplTokenGetAccountDataSizeInstructionData: {
+  SplTokenGetAccountDataSizeInstruction: {
     mint: resolveAccount("mint")
   },
-  SplTokenAmountToUiAmountInstructionData: {
+  SplTokenAmountToUiAmountInstruction: {
     mint: resolveAccount("mint")
   },
-  SplTokenUiAmountToAmountInstructionData: {
+  SplTokenUiAmountToAmountInstruction: {
     mint: resolveAccount("mint")
   },
-  SplTokenInitializeMintCloseAuthorityInstructionData: {
+  SplTokenInitializeMintCloseAuthorityInstruction: {
     mint: resolveAccount("mint"),
     newAuthority: resolveAccount("newAuthority")
   },
@@ -2510,45 +2224,45 @@ var instructionResolvers = {
     staker: resolveAccount("staker"),
     withdrawer: resolveAccount("withdrawer")
   },
-  StakeInitializeInstructionData: {
+  StakeInitializeInstruction: {
     stakeAccount: resolveAccount("stakeAccount")
   },
-  StakeAuthorizeInstructionData: {
+  StakeAuthorizeInstruction: {
     authority: resolveAccount("authority"),
     custodian: resolveAccount("custodian"),
     newAuthority: resolveAccount("newAuthority"),
     stakeAccount: resolveAccount("stakeAccount")
   },
-  StakeDelegateStakeInstructionData: {
+  StakeDelegateStakeInstruction: {
     stakeAccount: resolveAccount("stakeAccount"),
     stakeAuthority: resolveAccount("stakeAuthority"),
     stakeConfigAccount: resolveAccount("stakeConfigAccount"),
     voteAccount: resolveAccount("voteAccount")
   },
-  StakeSplitInstructionData: {
+  StakeSplitInstruction: {
     newSplitAccount: resolveAccount("newSplitAccount"),
     stakeAccount: resolveAccount("stakeAccount"),
     stakeAuthority: resolveAccount("stakeAuthority")
   },
-  StakeWithdrawInstructionData: {
+  StakeWithdrawInstruction: {
     destination: resolveAccount("destination"),
     stakeAccount: resolveAccount("stakeAccount"),
     withdrawAuthority: resolveAccount("withdrawAuthority")
   },
-  StakeDeactivateInstructionData: {
+  StakeDeactivateInstruction: {
     stakeAccount: resolveAccount("stakeAccount"),
     stakeAuthority: resolveAccount("stakeAuthority")
   },
-  StakeSetLockupInstructionData: {
+  StakeSetLockupInstruction: {
     custodian: resolveAccount("custodian"),
     stakeAccount: resolveAccount("stakeAccount")
   },
-  StakeMergeInstructionData: {
+  StakeMergeInstruction: {
     destination: resolveAccount("destination"),
     source: resolveAccount("source"),
     stakeAuthority: resolveAccount("stakeAuthority")
   },
-  StakeAuthorizeWithSeedInstructionData: {
+  StakeAuthorizeWithSeedInstruction: {
     authorityBase: resolveAccount("authorityBase"),
     authorityOwner: resolveAccount("authorityOwner"),
     custodian: resolveAccount("custodian"),
@@ -2556,154 +2270,153 @@ var instructionResolvers = {
     stakeAccount: resolveAccount("stakeAccount")
   },
   StakeInitializeCheckedInstructionDataAuthorized: {
-    stakeAccount: resolveAccount("stakeAccount"),
     staker: resolveAccount("staker"),
     withdrawer: resolveAccount("withdrawer")
   },
-  StakeAuthorizeCheckedInstructionData: {
+  StakeAuthorizeCheckedInstruction: {
     authority: resolveAccount("authority"),
     custodian: resolveAccount("custodian"),
     newAuthority: resolveAccount("newAuthority"),
     stakeAccount: resolveAccount("stakeAccount")
   },
-  StakeAuthorizeCheckedWithSeedInstructionData: {
+  StakeAuthorizeCheckedWithSeedInstruction: {
     authorityBase: resolveAccount("authorityBase"),
     authorityOwner: resolveAccount("authorityOwner"),
     custodian: resolveAccount("custodian"),
     newAuthorized: resolveAccount("newAuthorized"),
     stakeAccount: resolveAccount("stakeAccount")
   },
-  StakeSetLockupCheckedInstructionData: {
+  StakeSetLockupCheckedInstruction: {
     custodian: resolveAccount("custodian"),
     stakeAccount: resolveAccount("stakeAccount")
   },
-  StakeDeactivateDelinquentInstructionData: {
+  StakeDeactivateDelinquentInstruction: {
     referenceVoteAccount: resolveAccount("referenceVoteAccount"),
     stakeAccount: resolveAccount("stakeAccount"),
     voteAccount: resolveAccount("voteAccount")
   },
-  StakeRedelegateInstructionData: {
+  StakeRedelegateInstruction: {
     newStakeAccount: resolveAccount("newStakeAccount"),
     stakeAccount: resolveAccount("stakeAccount"),
     stakeAuthority: resolveAccount("stakeAuthority"),
     stakeConfigAccount: resolveAccount("stakeConfigAccount"),
     voteAccount: resolveAccount("voteAccount")
   },
-  CreateAccountInstructionData: {
+  CreateAccountInstruction: {
     newAccount: resolveAccount("newAccount"),
     owner: resolveAccount("owner"),
     source: resolveAccount("source")
   },
-  AssignInstructionData: {
+  AssignInstruction: {
     account: resolveAccount("account"),
     owner: resolveAccount("owner")
   },
-  TransferInstructionData: {
+  TransferInstruction: {
     destination: resolveAccount("destination"),
     source: resolveAccount("source")
   },
-  CreateAccountWithSeedInstructionData: {
+  CreateAccountWithSeedInstruction: {
     base: resolveAccount("base"),
     owner: resolveAccount("owner"),
     seed: resolveAccount("seed")
   },
-  AdvanceNonceAccountInstructionData: {
+  AdvanceNonceAccountInstruction: {
     nonceAccount: resolveAccount("nonceAccount"),
     nonceAuthority: resolveAccount("nonceAuthority")
   },
-  WithdrawNonceAccountInstructionData: {
+  WithdrawNonceAccountInstruction: {
     destination: resolveAccount("destination"),
     nonceAccount: resolveAccount("nonceAccount"),
     nonceAuthority: resolveAccount("nonceAuthority")
   },
-  InitializeNonceAccountInstructionData: {
+  InitializeNonceAccountInstruction: {
     nonceAccount: resolveAccount("nonceAccount"),
     nonceAuthority: resolveAccount("nonceAuthority")
   },
-  AuthorizeNonceAccountInstructionData: {
+  AuthorizeNonceAccountInstruction: {
     newAuthorized: resolveAccount("newAuthorized"),
     nonceAccount: resolveAccount("nonceAccount"),
     nonceAuthority: resolveAccount("nonceAuthority")
   },
-  UpgradeNonceAccountInstructionData: {
+  UpgradeNonceAccountInstruction: {
     nonceAccount: resolveAccount("nonceAccount"),
     nonceAuthority: resolveAccount("nonceAuthority")
   },
-  AllocateInstructionData: {
+  AllocateInstruction: {
     account: resolveAccount("account")
   },
-  AllocateWithSeedInstructionData: {
+  AllocateWithSeedInstruction: {
     account: resolveAccount("account"),
     owner: resolveAccount("owner")
   },
-  AssignWithSeedInstructionData: {
+  AssignWithSeedInstruction: {
     account: resolveAccount("account"),
     owner: resolveAccount("owner")
   },
-  TransferWithSeedInstructionData: {
+  TransferWithSeedInstruction: {
     destination: resolveAccount("destination"),
     source: resolveAccount("source"),
     sourceOwner: resolveAccount("sourceOwner")
   },
-  VoteInitializeAccountInstructionData: {
+  VoteInitializeAccountInstruction: {
     authorizedVoter: resolveAccount("authorizedVoter"),
     authorizedWithdrawer: resolveAccount("authorizedWithdrawer"),
     node: resolveAccount("node"),
     voteAccount: resolveAccount("voteAccount")
   },
-  VoteAuthorizeInstructionData: {
+  VoteAuthorizeInstruction: {
     authority: resolveAccount("authority"),
     newAuthority: resolveAccount("newAuthority"),
     voteAccount: resolveAccount("voteAccount")
   },
-  VoteAuthorizeWithSeedInstructionData: {
+  VoteAuthorizeWithSeedInstruction: {
     authorityOwner: resolveAccount("authorityOwner"),
     newAuthority: resolveAccount("newAuthority"),
     voteAccount: resolveAccount("voteAccount")
   },
-  VoteAuthorizeCheckedWithSeedInstructionData: {
+  VoteAuthorizeCheckedWithSeedInstruction: {
     authorityOwner: resolveAccount("authorityOwner"),
     newAuthority: resolveAccount("newAuthority"),
     voteAccount: resolveAccount("voteAccount")
   },
-  VoteVoteInstructionData: {
+  VoteVoteInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
-  VoteUpdateVoteStateInstructionData: {
+  VoteUpdateVoteStateInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
-  VoteUpdateVoteStateSwitchInstructionData: {
+  VoteUpdateVoteStateSwitchInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
-  VoteCompactUpdateVoteStateInstructionData: {
+  VoteCompactUpdateVoteStateInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
-  VoteCompactUpdateVoteStateSwitchInstructionData: {
+  VoteCompactUpdateVoteStateSwitchInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
-  VoteWithdrawInstructionData: {
+  VoteWithdrawInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     withdrawAuthority: resolveAccount("withdrawAuthority")
   },
-  VoteUpdateValidatorIdentityInstructionData: {
+  VoteUpdateValidatorIdentityInstruction: {
     newValidatorIdentity: resolveAccount("newValidatorIdentity"),
     voteAccount: resolveAccount("voteAccount"),
     withdrawAuthority: resolveAccount("withdrawAuthority")
   },
-  VoteUpdateCommissionInstructionData: {
+  VoteUpdateCommissionInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     withdrawAuthority: resolveAccount("withdrawAuthority")
   },
-  VoteVoteSwitchInstructionData: {
+  VoteVoteSwitchInstruction: {
     voteAccount: resolveAccount("voteAccount"),
     voteAuthority: resolveAccount("voteAuthority")
   },
-  VoteAuthorizeCheckedInstructionData: {
+  VoteAuthorizeCheckedInstruction: {
     authority: resolveAccount("authority"),
     newAuthority: resolveAccount("newAuthority"),
     voteAccount: resolveAccount("voteAccount")
@@ -2749,14 +2462,14 @@ var transactionTypeDefs = (
     }
 
     type TransactionMessageAccountKey {
-        pubkey: String
+        pubkey: Address
         signer: Boolean
         source: String
         writable: Boolean
     }
 
     type TransactionMessageAddressTableLookup {
-        accountKey: String
+        accountKey: Address
         readableIndexes: [Int]
         writableIndexes: [Int]
     }
@@ -2778,7 +2491,6 @@ var transactionTypeDefs = (
     # Transaction interface
     interface Transaction {
         blockTime: String
-        encoding: String
         meta: TransactionMeta
         slot: BigInt
         version: String
@@ -2787,8 +2499,7 @@ var transactionTypeDefs = (
     # A transaction with base58 encoded data
     type TransactionBase58 implements Transaction {
         blockTime: String
-        data: String
-        encoding: String
+        data: Base58EncodedBytes
         meta: TransactionMeta
         slot: BigInt
         version: String
@@ -2797,8 +2508,7 @@ var transactionTypeDefs = (
     # A transaction with base64 encoded data
     type TransactionBase64 implements Transaction {
         blockTime: String
-        data: String
-        encoding: String
+        data: Base64EncodedBytes
         meta: TransactionMeta
         slot: BigInt
         version: String
@@ -2812,7 +2522,6 @@ var transactionTypeDefs = (
     type TransactionParsed implements Transaction {
         blockTime: String
         data: TransactionDataParsed
-        encoding: String
         meta: TransactionMeta
         slot: BigInt
         version: String
@@ -2875,16 +2584,16 @@ var schemaTypeDefs = (
 var schemaResolvers = {
   Query: {
     account(_, args, context, info) {
-      return context.loadAccount(args, info);
+      return context.loaders.account.load(args, info);
     },
     block(_, args, context, info) {
-      return context.loadBlock(args, info);
+      return context.loaders.block.load(args, info);
     },
     programAccounts(_, args, context, info) {
-      return context.loadProgramAccounts(args, info);
+      return context.loaders.programAccounts.load(args, info);
     },
     transaction(_, args, context, info) {
-      return context.loadTransaction(args, info);
+      return context.loaders.transaction.load(args, info);
     }
   }
 };
@@ -2920,14 +2629,12 @@ function createRpcGraphQL(rpc) {
   return {
     context,
     async query(source, variableValues) {
-      const result = await graphql.graphql({
+      return graphql.graphql({
         contextValue: this.context,
         schema: this.schema,
         source,
         variableValues
       });
-      this.context.cache.flush();
-      return result;
     },
     schema
   };