@solana/rpc-graphql 2.0.0-experimental.dacecb7 → 2.0.0-experimental.e662875

package/dist/index.node.cjs

@@ -35,8 +35,29 @@ function createGraphQLCache() {
   };
 }
 
-// src/context.ts
-async function resolveAccount({ address, encoding = "jsonParsed", ...config }, cache, rpc) {
+// src/resolvers/account.ts
+function refineJsonParsedAccountData(jsonParsedData) {
+  const meta = {
+    program: jsonParsedData.program,
+    space: jsonParsedData.space,
+    type: jsonParsedData.parsed.type
+  };
+  const data = jsonParsedData.parsed.info;
+  return { data, meta };
+}
+async function resolveAccount({ address, encoding = "jsonParsed", ...config }, cache, rpc, info) {
+  if (info && info.fieldNodes[0].selectionSet) {
+    const selectionSet = info.fieldNodes[0].selectionSet;
+    const requestedFields = selectionSet.selections.map((field) => {
+      if (field.kind === "Field") {
+        return field.name.value;
+      }
+      return null;
+    });
+    if (requestedFields && requestedFields.length === 1 && requestedFields[0] === "address") {
+      return { address };
+    }
+  }
   const requestConfig = { encoding, ...config };
   const cached = cache.get(address, requestConfig);
   if (cached !== null) {
@@ -46,17 +67,29 @@ async function resolveAccount({ address, encoding = "jsonParsed", ...config }, c
     throw e;
   });
   if (account === null) {
-    return null;
+    return {
+      address
+    };
   }
-  const [data, responseEncoding] = Array.isArray(account.data) ? encoding === "jsonParsed" ? [account.data[0], "base64"] : [account.data[0], encoding] : [account.data, "jsonParsed"];
-  const queryResponse = {
+  const [refinedData, responseEncoding] = Array.isArray(account.data) ? encoding === "jsonParsed" ? [account.data[0], "base64"] : [account.data[0], encoding] : [refineJsonParsedAccountData(account.data), "jsonParsed"];
+  const responseBase = {
     ...account,
-    data,
+    address,
     encoding: responseEncoding
   };
+  const queryResponse = typeof refinedData === "object" && "meta" in refinedData ? {
+    ...responseBase,
+    data: refinedData.data,
+    meta: refinedData.meta
+  } : {
+    ...responseBase,
+    data: refinedData
+  };
   cache.insert(address, requestConfig, queryResponse);
   return queryResponse;
 }
+
+// src/resolvers/block.ts
 async function resolveBlock({ slot, encoding = "jsonParsed", ...config }, cache, rpc) {
   const requestConfig = { encoding, ...config };
   const cached = cache.get(slot, config);
@@ -70,6 +103,8 @@ async function resolveBlock({ slot, encoding = "jsonParsed", ...config }, cache,
   cache.insert(slot, config, block);
   return block;
 }
+
+// src/resolvers/program-accounts.ts
 async function resolveProgramAccounts({ programAddress, encoding = "jsonParsed", ...config }, cache, rpc) {
   const requestConfig = { encoding, ...config };
   const cached = cache.get(programAddress, requestConfig);
@@ -84,18 +119,28 @@ async function resolveProgramAccounts({ programAddress, encoding = "jsonParsed",
   }).catch((e) => {
     throw e;
   });
-  const queryResponse = programAccounts.map((programAccount2) => {
-    const [data, responseEncoding] = Array.isArray(programAccount2.account.data) ? encoding === "jsonParsed" ? [programAccount2.account.data[0], "base64"] : [programAccount2.account.data[0], encoding] : [programAccount2.account.data, "jsonParsed"];
-    const pubkey = programAccount2.pubkey;
-    const account = { ...programAccount2.account, data, encoding: responseEncoding };
-    return {
-      account,
-      pubkey
+  const queryResponse = 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
     };
   });
   cache.insert(programAddress, requestConfig, queryResponse);
   return queryResponse;
 }
+
+// src/resolvers/transaction.ts
 async function resolveTransaction({ signature, encoding = "jsonParsed", ...config }, cache, rpc) {
   const requestConfig = { encoding, ...config };
   const cached = cache.get(signature, requestConfig);
@@ -121,12 +166,14 @@ async function resolveTransaction({ signature, encoding = "jsonParsed", ...confi
   cache.insert(signature, requestConfig, queryResponse);
   return queryResponse;
 }
+
+// src/context.ts
 function createSolanaGraphQLContext(rpc) {
   const cache = createGraphQLCache();
   return {
     cache,
-    resolveAccount(args) {
-      return resolveAccount(args, this.cache, this.rpc);
+    resolveAccount(args, info) {
+      return resolveAccount(args, this.cache, this.rpc, info);
     },
     resolveBlock(args) {
       return resolveBlock(args, this.cache, this.rpc);
@@ -268,7 +315,7 @@ var dataSliceInputType = () => {
         length: number(),
         offset: number()
       },
-      name: "DataSliceConfig"
+      name: "DataSlice"
     });
   return memoisedDataSliceInputType;
 };
@@ -314,9 +361,6 @@ var transactionEncodingInputType = () => {
         base64: {
           value: "base64"
         },
-        json: {
-          value: "json"
-        },
         jsonParsed: {
           value: "jsonParsed"
         }
@@ -339,10 +383,25 @@ var tokenAmountType = () => {
   }
   return memoisedTokenAmountType;
 };
+var memoisedJsonParsedMeta;
+var jsonParsedMeta = () => {
+  if (!memoisedJsonParsedMeta) {
+    memoisedJsonParsedMeta = new graphql.GraphQLObjectType({
+      fields: {
+        program: string(),
+        space: bigint(),
+        type: string()
+      },
+      name: "JsonParsedMeta"
+    });
+  }
+  return memoisedJsonParsedMeta;
+};
 var memoisedAccountInterfaceFields;
 var accountInterfaceFields = () => {
   if (!memoisedAccountInterfaceFields) {
     memoisedAccountInterfaceFields = {
+      address: string(),
       encoding: string(),
       executable: boolean(),
       lamports: bigint(),
@@ -372,22 +431,22 @@ var accountInterface = () => {
           return "AccountBase64Zstd";
         }
         if (account.encoding === "jsonParsed") {
-          if (account.data.parsed.type === "mint" && account.data.program === "spl-token") {
+          if (account.meta.type === "mint" && account.meta.program === "spl-token") {
             return "MintAccount";
           }
-          if (account.data.parsed.type === "account" && account.data.program === "spl-token") {
+          if (account.meta.type === "account" && account.meta.program === "spl-token") {
             return "TokenAccount";
           }
-          if (account.data.program === "nonce") {
+          if (account.meta.program === "nonce") {
             return "NonceAccount";
           }
-          if (account.data.program === "stake") {
+          if (account.meta.program === "stake") {
             return "StakeAccount";
           }
-          if (account.data.parsed.type === "vote" && account.data.program === "vote") {
+          if (account.meta.type === "vote" && account.meta.program === "vote") {
             return "VoteAccount";
           }
-          if (account.data.parsed.type === "lookupTable" && account.data.program === "address-lookup-table") {
+          if (account.meta.type === "lookupTable" && account.meta.program === "address-lookup-table") {
             return "LookupTableAccount";
           }
         }
@@ -397,11 +456,11 @@ var accountInterface = () => {
   }
   return memoisedAccountInterface;
 };
-var accountType = (name, description, data) => new graphql.GraphQLObjectType({
-  description,
-  fields: {
+var accountType = (name, description, data, meta) => {
+  const fieldsBase = {
     ...accountInterfaceFields(),
     data,
+    // Nested Account interface
     owner: {
       args: {
         commitment: type(commitmentInputType()),
@@ -409,31 +468,42 @@ var accountType = (name, description, data) => new graphql.GraphQLObjectType({
         encoding: type(accountEncodingInputType()),
         minContextSlot: bigint()
       },
-      resolve: (parent, args, context) => context.resolveAccount({ ...args, address: parent.owner }),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
       type: accountInterface()
     }
-  },
-  interfaces: [accountInterface()],
-  name
-});
-var accountDataJsonParsed = (name, parsedInfoFields) => object(name + "Data", {
-  parsed: object(name + "DataParsed", {
-    info: object(name + "DataParsedInfo", parsedInfoFields),
-    type: string()
-  }),
-  program: string(),
-  space: bigint()
-});
+  };
+  const graphQLObject = (fields) => new graphql.GraphQLObjectType({
+    description,
+    fields,
+    interfaces: [accountInterface()],
+    name
+  });
+  return meta ? graphQLObject({
+    ...fieldsBase,
+    meta: type(jsonParsedMeta())
+  }) : graphQLObject(fieldsBase);
+};
 var memoisedAccountBase58;
 var accountBase58 = () => {
   if (!memoisedAccountBase58)
-    memoisedAccountBase58 = accountType("AccountBase58", "A Solana account with base58 encoded data", string());
+    memoisedAccountBase58 = accountType(
+      "AccountBase58",
+      "A Solana account with base58 encoded data",
+      string(),
+      false
+    );
   return memoisedAccountBase58;
 };
 var memoisedAccountBase64;
 var accountBase64 = () => {
   if (!memoisedAccountBase64)
-    memoisedAccountBase64 = accountType("AccountBase64", "A Solana account with base64 encoded data", string());
+    memoisedAccountBase64 = accountType(
+      "AccountBase64",
+      "A Solana account with base64 encoded data",
+      string(),
+      false
+    );
   return memoisedAccountBase64;
 };
 var memoisedAccountBase64Zstd;
@@ -442,7 +512,8 @@ var accountBase64Zstd = () => {
     memoisedAccountBase64Zstd = accountType(
       "AccountBase64Zstd",
       "A Solana account with base64 encoded data compressed with zstd",
-      string()
+      string(),
+      false
     );
   return memoisedAccountBase64Zstd;
 };
@@ -452,13 +523,25 @@ var accountNonceAccount = () => {
     memoisedAccountNonceAccount = accountType(
       "NonceAccount",
       "A nonce account",
-      accountDataJsonParsed("Nonce", {
-        authority: string(),
+      object("NonceData", {
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
         blockhash: string(),
         feeCalculator: object("NonceFeeCalculator", {
           lamportsPerSignature: string()
         })
-      })
+      }),
+      true
     );
   return memoisedAccountNonceAccount;
 };
@@ -468,13 +551,25 @@ var accountLookupTable = () => {
     memoisedAccountLookupTable = accountType(
       "LookupTableAccount",
       "An address lookup table account",
-      accountDataJsonParsed("LookupTable", {
+      object("LookupTableData", {
         addresses: list(string()),
-        authority: string(),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
         deactivationSlot: string(),
         lastExtendedSlot: string(),
         lastExtendedSlotStartIndex: number()
-      })
+      }),
+      true
     );
   return memoisedAccountLookupTable;
 };
@@ -484,13 +579,25 @@ var accountMint = () => {
     memoisedAccountMint = accountType(
       "MintAccount",
       "An SPL mint",
-      accountDataJsonParsed("Mint", {
+      object("MintData", {
         decimals: number(),
         freezeAuthority: string(),
         isInitialized: boolean(),
-        mintAuthority: string(),
+        // Nested Account interface
+        mintAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mintAuthority }, info),
+          type: accountInterface()
+        },
         supply: string()
-      })
+      }),
+      true
     );
   return memoisedAccountMint;
 };
@@ -500,13 +607,25 @@ var accountTokenAccount = () => {
     memoisedAccountTokenAccount = accountType(
       "TokenAccount",
       "An SPL token account",
-      accountDataJsonParsed("TokenAccount", {
+      object("TokenAccountData", {
         isNative: boolean(),
         mint: string(),
-        owner: string(),
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
         state: string(),
         tokenAmount: type(tokenAmountType())
-      })
+      }),
+      true
     );
   return memoisedAccountTokenAccount;
 };
@@ -516,14 +635,47 @@ var accountStakeAccount = () => {
     memoisedAccountStakeAccount = accountType(
       "StakeAccount",
       "A stake account",
-      accountDataJsonParsed("Stake", {
+      object("StakeData", {
         meta: object("StakeMeta", {
           authorized: object("StakeMetaAuthorized", {
-            staker: string(),
-            withdrawer: string()
+            // Nested Account interface
+            staker: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.staker }, info),
+              type: accountInterface()
+            },
+            // Nested Account interface
+            withdrawer: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.withdrawer }, info),
+              type: accountInterface()
+            }
           }),
           lockup: object("StakeMetaLockup", {
-            custodian: string(),
+            // Nested Account interface
+            custodian: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+              type: accountInterface()
+            },
             epoch: bigint(),
             unixTimestamp: bigint()
           }),
@@ -535,11 +687,23 @@ var accountStakeAccount = () => {
             activationEpoch: bigint(),
             deactivationEpoch: bigint(),
             stake: string(),
-            voter: string(),
+            // Nested Account interface
+            voter: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voter }, info),
+              type: accountInterface()
+            },
             warmupCooldownRate: number()
           })
         })
-      })
+      }),
+      true
     );
   return memoisedAccountStakeAccount;
 };
@@ -549,14 +713,36 @@ var accountVoteAccount = () => {
     memoisedAccountVoteAccount = accountType(
       "VoteAccount",
       "A vote account",
-      accountDataJsonParsed("Vote", {
+      object("VoteData", {
         authorizedVoters: list(
           object("VoteAuthorizedVoter", {
-            authorizedVoter: string(),
+            // Nested Account interface
+            authorizedVoter: {
+              args: {
+                commitment: type(commitmentInputType()),
+                dataSlice: type(dataSliceInputType()),
+                encoding: type(accountEncodingInputType()),
+                minContextSlot: bigint()
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorizedVoter }, info),
+              type: accountInterface()
+            },
             epoch: bigint()
           })
         ),
-        authorizedWithdrawer: string(),
+        // Nested Account interface
+        authorizedWithdrawer: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorizedWithdrawer }, info),
+          type: accountInterface()
+        },
         commission: number(),
         epochCredits: list(
           object("VoteEpochCredits", {
@@ -569,7 +755,18 @@ var accountVoteAccount = () => {
           slot: bigint(),
           timestamp: bigint()
         }),
-        nodePubkey: string(),
+        // Nested Account interface
+        node: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nodePubkey }, info),
+          type: accountInterface()
+        },
         priorVoters: list(string()),
         rootSlot: bigint(),
         votes: list(
@@ -578,7 +775,8 @@ var accountVoteAccount = () => {
             slot: bigint()
           })
         )
-      })
+      }),
+      true
     );
   return memoisedAccountVoteAccount;
 };
@@ -609,7 +807,8 @@ var accountQuery = () => ({
       encoding: type(accountEncodingInputType()),
       minContextSlot: bigint()
     },
-    resolve: (_parent, args, context) => context.resolveAccount(args),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resolve: (_parent, args, context, info) => context.resolveAccount(args, info),
     type: accountInterface()
   }
 });
@@ -619,8 +818,30 @@ var tokenBalance = () => {
     memoisedTokenBalance = new graphql.GraphQLObjectType({
       fields: {
         accountIndex: number(),
-        mint: string(),
-        owner: string(),
+        // Nested Account interface
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
         programId: string(),
         uiAmountString: string()
       },
@@ -1040,30 +1261,184 @@ var parsedInstructionsAddressLookupTable = () => {
     memoisedParsedInstructionsAddressLookupTable = [
       parsedTransactionInstructionType("CreateLookupTableInstruction", {
         bumpSeed: number(),
-        lookupTableAccount: string(),
-        lookupTableAuthority: string(),
-        payerAccount: string(),
+        // Nested Account interface
+        lookupTableAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        lookupTableAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        payerAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.payerAccount }, info),
+          type: accountInterface()
+        },
         recentSlot: bigint(),
-        systemProgram: string()
+        // Nested Account interface
+        systemProgram: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.systemProgram }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("FreezeLookupTableInstruction", {
-        lookupTableAccount: string(),
-        lookupTableAuthority: string()
+        // Nested Account interface
+        lookupTableAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        lookupTableAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("ExtendLookupTableInstruction", {
-        lookupTableAccount: string(),
-        lookupTableAuthority: string(),
+        // Nested Account interface
+        lookupTableAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        lookupTableAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAuthority }, info),
+          type: accountInterface()
+        },
         newAddresses: list(string()),
-        payerAccount: string(),
-        systemProgram: string()
+        // Nested Account interface
+        payerAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.payerAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        systemProgram: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.systemProgram }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("DeactivateLookupTableInstruction", {
-        lookupTableAccount: string(),
-        lookupTableAuthority: string()
+        // Nested Account interface
+        lookupTableAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        lookupTableAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("CloseLookupTableInstruction", {
-        lookupTableAccount: string(),
-        lookupTableAuthority: string(),
+        // Nested Account interface
+        lookupTableAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        lookupTableAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.lookupTableAuthority }, info),
+          type: accountInterface()
+        },
         recipient: string()
       })
     ];
@@ -1074,12 +1449,34 @@ var parsedInstructionsBpfLoader = () => {
   if (!memoisedParsedInstructionsBpfLoader)
     memoisedParsedInstructionsBpfLoader = [
       parsedTransactionInstructionType("BpfLoaderWriteInstruction", {
-        account: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
         bytes: string(),
         offset: number()
       }),
       parsedTransactionInstructionType("BpfLoaderFinalizeInstruction", {
-        account: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        }
       })
     ];
   return memoisedParsedInstructionsBpfLoader;
@@ -1089,55 +1486,329 @@ var parsedInstructionsBpfUpgradeableLoader = () => {
   if (!memoisedParsedInstructionsBpfUpgradeableLoader)
     memoisedParsedInstructionsBpfUpgradeableLoader = [
       parsedTransactionInstructionType("BpfUpgradeableLoaderInitializeBufferInstruction", {
-        account: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("BpfUpgradeableLoaderWriteInstruction", {
-        account: string(),
-        authority: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
         bytes: string(),
         offset: number()
       }),
       parsedTransactionInstructionType("BpfUpgradeableLoaderDeployWithMaxDataLenInstruction", {
-        authority: string(),
-        bufferAccount: string(),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        bufferAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.bufferAccount }, info),
+          type: accountInterface()
+        },
         clockSysvar: string(),
         maxDataLen: bigint(),
-        payerAccount: string(),
-        programAccount: string(),
-        programDataAccount: string(),
+        // Nested Account interface
+        payerAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.payerAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        programAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.programAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        programDataAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.programDataAccount }, info),
+          type: accountInterface()
+        },
         rentSysvar: string()
       }),
       parsedTransactionInstructionType("BpfUpgradeableLoaderUpgradeInstruction", {
-        authority: string(),
-        bufferAccount: string(),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        bufferAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.bufferAccount }, info),
+          type: accountInterface()
+        },
         clockSysvar: string(),
-        programAccount: string(),
-        programDataAccount: string(),
+        // Nested Account interface
+        programAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.programAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        programDataAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.programDataAccount }, info),
+          type: accountInterface()
+        },
         rentSysvar: string(),
-        spillAccount: string()
+        // Nested Account interface
+        spillAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.spillAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("BpfUpgradeableLoaderSetAuthorityInstruction", {
         account: string(),
-        authority: string(),
-        newAuthority: string()
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("BpfUpgradeableLoaderSetAuthorityCheckedInstruction", {
-        account: string(),
-        authority: string(),
-        newAuthority: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("BpfUpgradeableLoaderCloseInstruction", {
-        account: string(),
-        authority: string(),
-        programAccount: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        programAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.programAccount }, info),
+          type: accountInterface()
+        },
         recipient: string()
       }),
       parsedTransactionInstructionType("BpfUpgradeableLoaderExtendProgramInstruction", {
         additionalBytes: bigint(),
-        payerAccount: string(),
-        programAccount: string(),
-        programDataAccount: string(),
-        systemProgram: string()
+        payerAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.payerAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        programAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.programAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        programDataAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.programDataAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        systemProgram: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.systemProgram }, info),
+          type: accountInterface()
+        }
       })
     ];
   return memoisedParsedInstructionsBpfUpgradeableLoader;
@@ -1147,29 +1818,221 @@ var parsedInstructionsSplAssociatedToken = () => {
   if (!memoisedParsedInstructionsSplAssociatedToken)
     memoisedParsedInstructionsSplAssociatedToken = [
       parsedTransactionInstructionType("SplAssociatedTokenCreateInstruction", {
-        account: string(),
-        mint: string(),
-        source: string(),
-        systemProgram: string(),
-        tokenProgram: string(),
-        wallet: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        },
+        systemProgram: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.systemProgram }, info),
+          type: accountInterface()
+        },
+        tokenProgram: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.tokenProgram }, info),
+          type: accountInterface()
+        },
+        wallet: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.wallet }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplAssociatedTokenCreateIdempotentInstruction", {
-        account: string(),
-        mint: string(),
-        source: string(),
-        systemProgram: string(),
-        tokenProgram: string(),
-        wallet: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        },
+        systemProgram: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.systemProgram }, info),
+          type: accountInterface()
+        },
+        tokenProgram: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.tokenProgram }, info),
+          type: accountInterface()
+        },
+        wallet: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.wallet }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplAssociatedTokenRecoverNestedInstruction", {
-        destination: string(),
-        nestedMint: string(),
-        nestedOwner: string(),
-        nestedSource: string(),
-        ownerMint: string(),
-        tokenProgram: string(),
-        wallet: string()
+        destination: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.destination }, info),
+          type: accountInterface()
+        },
+        nestedMint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nestedMint }, info),
+          type: accountInterface()
+        },
+        nestedOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nestedOwner }, info),
+          type: accountInterface()
+        },
+        nestedSource: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nestedSource }, info),
+          type: accountInterface()
+        },
+        ownerMint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.ownerMint }, info),
+          type: accountInterface()
+        },
+        tokenProgram: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.tokenProgram }, info),
+          type: accountInterface()
+        },
+        wallet: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.wallet }, info),
+          type: accountInterface()
+        }
       })
     ];
   return memoisedParsedInstructionsSplAssociatedToken;
@@ -1194,155 +2057,980 @@ var parsedInstructionsSplToken = () => {
     memoisedParsedInstructionsSplToken = [
       parsedTransactionInstructionType("SplTokenInitializeMintInstruction", {
         decimals: number(),
-        freezeAuthority: string(),
-        mint: string(),
-        mintAuthority: string(),
+        freezeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.freezeAuthority }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        mintAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mintAuthority }, info),
+          type: accountInterface()
+        },
         rentSysvar: string()
       }),
       parsedTransactionInstructionType("SplTokenInitializeMint2Instruction", {
         decimals: number(),
-        freezeAuthority: string(),
-        mint: string(),
-        mintAuthority: string()
+        freezeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.freezeAuthority }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        mintAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mintAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenInitializeAccountInstruction", {
-        account: string(),
-        mint: string(),
-        owner: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
         rentSysvar: string()
       }),
       parsedTransactionInstructionType("SplTokenInitializeAccount2Instruction", {
-        account: string(),
-        mint: string(),
-        owner: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
         rentSysvar: string()
       }),
       parsedTransactionInstructionType("SplTokenInitializeAccount3Instruction", {
-        account: string(),
-        mint: string(),
-        owner: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenInitializeMultisigInstruction", {
         m: number(),
-        multisig: string(),
+        // Nested Account interface
+        multisig: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisig }, info),
+          type: accountInterface()
+        },
         rentSysvar: string(),
         signers: list(string())
       }),
       parsedTransactionInstructionType("SplTokenInitializeMultisig2Instruction", {
         m: number(),
-        multisig: string(),
+        // Nested Account interface
+        multisig: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisig }, info),
+          type: accountInterface()
+        },
         signers: list(string())
       }),
       parsedTransactionInstructionType("SplTokenTransferInstruction", {
         amount: string(),
-        authority: string(),
-        destination: string(),
-        multisigAuthority: string(),
-        source: string()
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        destination: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.destination }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigAuthority }, info),
+          type: accountInterface()
+        },
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenApproveInstruction", {
         amount: string(),
-        delegate: string(),
-        multisigOwner: string(),
-        owner: string(),
-        source: string()
+        // Nested Account interface
+        delegate: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.delegate }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigOwner }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenRevokeInstruction", {
-        multisigOwner: string(),
-        owner: string(),
-        source: string()
+        // Nested Account interface
+        multisigOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigOwner }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenSetAuthorityInstruction", {
-        authority: string(),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
         authorityType: string(),
-        multisigAuthority: string(),
-        newAuthority: string()
+        // Nested Account interface
+        multisigAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenMintToInstruction", {
-        account: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
         amount: string(),
-        authority: string(),
-        mint: string(),
-        mintAuthority: string(),
-        multisigMintAuthority: string()
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        mintAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mintAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigMintAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigMintAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenBurnInstruction", {
-        account: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
         amount: string(),
-        authority: string(),
-        mint: string(),
-        multisigAuthority: string()
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenCloseAccountInstruction", {
-        account: string(),
-        destination: string(),
-        multisigOwner: string(),
-        owner: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        destination: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.destination }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigOwner }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenFreezeAccountInstruction", {
-        account: string(),
-        freezeAuthority: string(),
-        mint: string(),
-        multisigFreezeAuthority: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        freezeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.freezeAuthority }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigFreezeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigFreezeAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenThawAccountInstruction", {
-        account: string(),
-        freezeAuthority: string(),
-        mint: string(),
-        multisigFreezeAuthority: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        freezeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.freezeAuthority }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigFreezeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigFreezeAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenTransferCheckedInstruction", {
-        authority: string(),
-        destination: string(),
-        mint: string(),
-        multisigAuthority: string(),
-        source: string(),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        destination: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.destination }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigAuthority }, info),
+          type: accountInterface()
+        },
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        },
         tokenAmount: string()
       }),
       parsedTransactionInstructionType("SplTokenApproveCheckedInstruction", {
-        delegate: string(),
-        mint: string(),
-        multisigOwner: string(),
-        owner: string(),
-        source: string(),
+        // Nested Account interface
+        delegate: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.delegate }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigOwner }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        },
         tokenAmount: string()
       }),
       parsedTransactionInstructionType("SplTokenMintToCheckedInstruction", {
-        account: string(),
-        authority: string(),
-        mint: string(),
-        mintAuthority: string(),
-        multisigMintAuthority: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        mintAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mintAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigMintAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigMintAuthority }, info),
+          type: accountInterface()
+        },
         tokenAmount: string()
       }),
       parsedTransactionInstructionType("SplTokenBurnCheckedInstruction", {
-        account: string(),
-        authority: string(),
-        mint: string(),
-        multisigAuthority: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        multisigAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.multisigAuthority }, info),
+          type: accountInterface()
+        },
         tokenAmount: string()
       }),
       parsedTransactionInstructionType("SplTokenSyncNativeInstruction", {
-        account: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenGetAccountDataSizeInstruction", {
         extensionTypes: list(string()),
-        mint: string()
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenInitializeImmutableOwnerInstruction", {
-        account: string()
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenAmountToUiAmountInstruction", {
         amount: string(),
-        mint: string()
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("SplTokenUiAmountToAmountInstruction", {
-        mint: string(),
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
         uiAmount: string()
       }),
       parsedTransactionInstructionType("SplTokenInitializeMintCloseAuthorityInstruction", {
-        mint: string(),
-        newAuthority: string()
+        mint: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.mint }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        }
       })
       // TODO: Extensions!
       // - TransferFeeExtension
@@ -1367,7 +3055,18 @@ var lockup = () => {
   if (!memoisedLockup)
     memoisedLockup = new graphql.GraphQLObjectType({
       fields: {
-        custodian: string(),
+        // Nested Account interface
+        custodian: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+          type: accountInterface()
+        },
         epoch: bigint(),
         unixTimestamp: bigint()
       },
@@ -1381,113 +3080,649 @@ var parsedInstructionsStake = () => {
     memoisedParsedInstructionsStake = [
       parsedTransactionInstructionType("StakeInitializeInstruction", {
         authorized: object("StakeInitializeInstructionAuthorized", {
-          staker: string(),
-          withdrawer: string()
+          // Nested Account interface
+          staker: {
+            args: {
+              commitment: type(commitmentInputType()),
+              dataSlice: type(dataSliceInputType()),
+              encoding: type(accountEncodingInputType()),
+              minContextSlot: bigint()
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.staker }, info),
+            type: accountInterface()
+          },
+          // Nested Account interface
+          withdrawer: {
+            args: {
+              commitment: type(commitmentInputType()),
+              dataSlice: type(dataSliceInputType()),
+              encoding: type(accountEncodingInputType()),
+              minContextSlot: bigint()
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.withdrawer }, info),
+            type: accountInterface()
+          }
         }),
         lockup: object("StakeInitializeInstructionLockup", {
-          custodian: string(),
+          // Nested Account interface
+          custodian: {
+            args: {
+              commitment: type(commitmentInputType()),
+              dataSlice: type(dataSliceInputType()),
+              encoding: type(accountEncodingInputType()),
+              minContextSlot: bigint()
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+            type: accountInterface()
+          },
           epoch: bigint(),
           unixTimestamp: bigint()
         }),
         rentSysvar: string(),
-        stakeAccount: string()
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeAuthorizeInstruction", {
-        authority: string(),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
         authorityType: string(),
         clockSysvar: string(),
-        custodian: string(),
-        newAuthority: string(),
-        stakeAccount: string()
+        // Nested Account interface
+        custodian: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeDelegateStakeInstruction", {
         clockSysvar: string(),
-        stakeAccount: string(),
-        stakeAuthority: string(),
-        stakeConfigAccount: string(),
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeConfigAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeConfigAccount }, info),
+          type: accountInterface()
+        },
         stakeHistorySysvar: string(),
-        voteAccount: string()
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeSplitInstruction", {
         lamports: bigint(),
         newSplitAccount: string(),
-        stakeAccount: string(),
-        stakeAuthority: string()
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeWithdrawInstruction", {
         clockSysvar: string(),
-        destination: string(),
+        destination: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.destination }, info),
+          type: accountInterface()
+        },
         lamports: bigint(),
-        stakeAccount: string(),
-        withdrawAuthority: string()
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        withdrawAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.withdrawAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeDeactivateInstruction", {
         clockSysvar: string(),
-        stakeAccount: string(),
-        stakeAuthority: string()
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeSetLockupInstruction", {
-        custodian: string(),
+        // Nested Account interface
+        custodian: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+          type: accountInterface()
+        },
         lockup: type(lockup()),
-        stakeAccount: string()
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeMergeInstruction", {
         clockSysvar: string(),
-        destination: string(),
-        source: string(),
-        stakeAuthority: string(),
+        destination: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.destination }, info),
+          type: accountInterface()
+        },
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAuthority }, info),
+          type: accountInterface()
+        },
         stakeHistorySysvar: string()
       }),
       parsedTransactionInstructionType("StakeAuthorizeWithSeedInstruction", {
-        authorityBase: string(),
-        authorityOwner: string(),
+        // Nested Account interface
+        authorityBase: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorityBase }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authorityOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorityOwner }, info),
+          type: accountInterface()
+        },
         authoritySeed: string(),
         authorityType: string(),
         clockSysvar: string(),
-        custodian: string(),
-        newAuthorized: string(),
-        stakeAccount: string()
+        // Nested Account interface
+        custodian: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        newAuthorized: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthorized }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeInitializeCheckedInstruction", {
         rentSysvar: string(),
-        stakeAccount: string(),
-        staker: string(),
-        withdrawer: string()
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        staker: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.staker }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        withdrawer: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.withdrawer }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeAuthorizeCheckedInstruction", {
-        authority: string(),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
         authorityType: string(),
         clockSysvar: string(),
-        custodian: string(),
-        newAuthority: string(),
-        stakeAccount: string()
+        // Nested Account interface
+        custodian: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeAuthorizeCheckedWithSeedInstruction", {
-        authorityBase: string(),
-        authorityOwner: string(),
+        // Nested Account interface
+        authorityBase: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorityBase }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authorityOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorityOwner }, info),
+          type: accountInterface()
+        },
         authoritySeed: string(),
         authorityType: string(),
         clockSysvar: string(),
-        custodian: string(),
-        newAuthorized: string(),
-        stakeAccount: string()
+        // Nested Account interface
+        custodian: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        newAuthorized: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthorized }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeSetLockupCheckedInstruction", {
-        custodian: string(),
+        // Nested Account interface
+        custodian: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.custodian }, info),
+          type: accountInterface()
+        },
         lockup: type(lockup()),
-        stakeAccount: string()
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeDeactivateDelinquentInstruction", {
         referenceVoteAccount: string(),
-        stakeAccount: string(),
-        voteAccount: string()
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("StakeRedelegateInstruction", {
         newStakeAccount: string(),
-        stakeAccount: string(),
-        stakeAuthority: string(),
-        stakeConfigAccount: string(),
-        voteAccount: string()
+        // Nested Account interface
+        stakeAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        stakeConfigAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.stakeConfigAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        }
       })
     ];
   return memoisedParsedInstructionsStake;
@@ -1498,76 +3733,357 @@ var parsedInstructionsSystem = () => {
     memoisedParsedInstructionsSystem = [
       parsedTransactionInstructionType("CreateAccountInstruction", {
         lamports: bigint(),
-        newAccount: string(),
-        owner: string(),
-        source: string(),
+        // Nested Account interface
+        newAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        },
         space: bigint()
       }),
       parsedTransactionInstructionType("AssignInstruction", {
-        owner: string()
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("TransferInstruction", {
         amount: string(),
         lamports: number(),
-        source: string()
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("CreateAccountWithSeedInstruction", {
         base: string(),
         lamports: bigint(),
-        owner: string(),
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
         seed: string(),
         space: bigint()
       }),
       parsedTransactionInstructionType("AdvanceNonceAccountInstruction", {
-        nonceAccount: string(),
-        nonceAuthority: string(),
+        // Nested Account interface
+        nonceAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nonceAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        nonceAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nonceAuthority }, info),
+          type: accountInterface()
+        },
         recentBlockhashesSysvar: string()
       }),
       parsedTransactionInstructionType("WithdrawNonceAccountInstruction", {
-        destination: string(),
+        destination: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.destination }, info),
+          type: accountInterface()
+        },
         lamports: bigint(),
-        nonceAccount: string(),
-        nonceAuthority: string(),
+        // Nested Account interface
+        nonceAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nonceAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        nonceAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nonceAuthority }, info),
+          type: accountInterface()
+        },
         recentBlockhashesSysvar: string(),
         rentSysvar: string()
       }),
       parsedTransactionInstructionType("InitializeNonceAccountInstruction", {
-        nonceAccount: string(),
-        nonceAuthority: string(),
+        // Nested Account interface
+        nonceAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nonceAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        nonceAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nonceAuthority }, info),
+          type: accountInterface()
+        },
         recentBlockhashesSysvar: string(),
         rentSysvar: string()
       }),
       parsedTransactionInstructionType("AuthorizeNonceAccountInstruction", {
-        newAuthorized: string(),
-        nonceAccount: string(),
-        nonceAuthority: string()
+        // Nested Account interface
+        newAuthorized: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthorized }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        nonceAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nonceAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        nonceAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nonceAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("UpgradeNonceAccountInstruction", {
-        nonceAccount: string()
+        // Nested Account interface
+        nonceAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.nonceAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("AllocateInstruction", {
-        account: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
         space: bigint()
       }),
       parsedTransactionInstructionType("AllocateWithSeedInstruction", {
-        account: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
         base: string(),
-        owner: string(),
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
         seed: string(),
         space: bigint()
       }),
       parsedTransactionInstructionType("AssignWithSeedInstruction", {
-        account: string(),
+        // Nested Account interface
+        account: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.account }, info),
+          type: accountInterface()
+        },
         base: string(),
-        owner: string(),
+        // Nested Account interface
+        owner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
+          type: accountInterface()
+        },
         seed: string()
       }),
       parsedTransactionInstructionType("TransferWithSeedInstruction", {
-        destination: string(),
+        destination: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.destination }, info),
+          type: accountInterface()
+        },
         lamports: bigint(),
-        source: string(),
-        sourceBase: string(),
-        sourceOwner: string(),
+        source: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.source }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        sourceBase: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.sourceBase }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        sourceOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.sourceOwner }, info),
+          type: accountInterface()
+        },
         sourceSeed: string()
       })
     ];
@@ -1610,100 +4126,506 @@ var parsedInstructionsVote = () => {
   if (!memoisedParsedInstructionsVote)
     memoisedParsedInstructionsVote = [
       parsedTransactionInstructionType("VoteInitializeAccountInstruction", {
-        authorizedVoter: string(),
-        authorizedWithdrawer: string(),
+        // Nested Account interface
+        authorizedVoter: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorizedVoter }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authorizedWithdrawer: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorizedWithdrawer }, info),
+          type: accountInterface()
+        },
         clockSysvar: string(),
         commission: number(),
         node: string(),
         rentSysvar: string(),
-        voteAccount: string()
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("VoteAuthorizeInstruction", {
-        authority: string(),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
         authorityType: string(),
         clockSysvar: string(),
-        newAuthority: string(),
-        voteAccount: string()
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("VoteAuthorizeWithSeedInstruction", {
-        authorityBaseKey: string(),
-        authorityOwner: string(),
+        // Nested Account interface
+        authorityBaseKey: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorityBaseKey }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authorityOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorityOwner }, info),
+          type: accountInterface()
+        },
         authoritySeed: string(),
         authorityType: string(),
         clockSysvar: string(),
-        newAuthority: string(),
-        voteAccount: string()
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("VoteAuthorizeCheckedWithSeedInstruction", {
-        authorityBaseKey: string(),
-        authorityOwner: string(),
+        // Nested Account interface
+        authorityBaseKey: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorityBaseKey }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        authorityOwner: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authorityOwner }, info),
+          type: accountInterface()
+        },
         authoritySeed: string(),
         authorityType: string(),
         clockSysvar: string(),
-        newAuthority: string(),
-        voteAccount: string()
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("VoteVoteInstruction", {
         clockSysvar: string(),
         slotHashedSysvar: string(),
         vote: type(vote()),
-        voteAccount: string(),
-        voteAuthority: string()
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("VoteUpdateVoteStateInstruction", {
         hash: string(),
-        voteAccount: string(),
-        voteAuthority: string(),
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAuthority }, info),
+          type: accountInterface()
+        },
         voteStateUpdate: type(voteStateUpdate())
       }),
       parsedTransactionInstructionType("VoteUpdateVoteStateSwitchInstruction", {
         hash: string(),
-        voteAccount: string(),
-        voteAuthority: string(),
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAuthority }, info),
+          type: accountInterface()
+        },
         voteStateUpdate: type(voteStateUpdate())
       }),
       parsedTransactionInstructionType("VoteCompactUpdateVoteStateInstruction", {
         hash: string(),
-        voteAccount: string(),
-        voteAuthority: string(),
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAuthority }, info),
+          type: accountInterface()
+        },
         voteStateUpdate: type(voteStateUpdate())
       }),
       parsedTransactionInstructionType("VoteCompactUpdateVoteStateSwitchInstruction", {
         hash: string(),
-        voteAccount: string(),
-        voteAuthority: string(),
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAuthority }, info),
+          type: accountInterface()
+        },
         voteStateUpdate: type(voteStateUpdate())
       }),
       parsedTransactionInstructionType("VoteWithdrawInstruction", {
-        destination: string(),
+        destination: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.destination }, info),
+          type: accountInterface()
+        },
         lamports: bigint(),
-        voteAccount: string(),
-        withdrawAuthority: string()
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        withdrawAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.withdrawAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("VoteUpdateValidatorIdentityInstruction", {
-        newValidatorIdentity: string(),
-        voteAccount: string(),
-        withdrawAuthority: string()
+        // Nested Account interface
+        newValidatorIdentity: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newValidatorIdentity }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        withdrawAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.withdrawAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("VoteUpdateCommissionInstruction", {
         commission: string(),
-        voteAccount: string(),
-        withdrawAuthority: string()
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        withdrawAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.withdrawAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("VoteVoteSwitchInstruction", {
         clockSysvar: string(),
         hash: string(),
         slotHashesSysvar: string(),
         vote: type(vote()),
-        voteAccount: string(),
-        voteAuthority: string()
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAuthority }, info),
+          type: accountInterface()
+        }
       }),
       parsedTransactionInstructionType("VoteAuthorizeCheckedInstruction", {
-        authority: string(),
+        // Nested Account interface
+        authority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.authority }, info),
+          type: accountInterface()
+        },
         authorityType: string(),
         clockSysvar: string(),
-        newAuthority: string(),
-        voteAccount: string()
+        // Nested Account interface
+        newAuthority: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.newAuthority }, info),
+          type: accountInterface()
+        },
+        // Nested Account interface
+        voteAccount: {
+          args: {
+            commitment: type(commitmentInputType()),
+            dataSlice: type(dataSliceInputType()),
+            encoding: type(accountEncodingInputType()),
+            minContextSlot: bigint()
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.voteAccount }, info),
+          type: accountInterface()
+        }
       })
     ];
   return memoisedParsedInstructionsVote;
@@ -1789,83 +4711,40 @@ var transactionMetaParsed = () => {
     );
   return memoisedTransactionMetaParsed;
 };
-var memoisedTransactionMessageInterfaceFields;
-var transactionMessageInterfaceFields = () => {
-  if (!memoisedTransactionMessageInterfaceFields)
-    memoisedTransactionMessageInterfaceFields = {
-      addressTableLookups: list(type(addressTableLookup())),
-      format: string(),
-      header: object("TransactionJsonTransactionHeader", {
-        numReadonlySignedAccounts: number(),
-        numReadonlyUnsignedAccounts: number(),
-        numRequiredSignatures: number()
-      }),
-      recentBlockhash: string()
-    };
-  return memoisedTransactionMessageInterfaceFields;
-};
-var memoisedTransactionMessageInterface;
-var transactionMessageInterface = () => {
-  if (!memoisedTransactionMessageInterface)
-    memoisedTransactionMessageInterface = new graphql.GraphQLInterfaceType({
+var memoisedTransactionMessage;
+var transactionMessage = () => {
+  if (!memoisedTransactionMessage)
+    memoisedTransactionMessage = new graphql.GraphQLObjectType({
+      description: "A transaction message",
       fields: {
-        ...transactionMessageInterfaceFields()
+        accountKeys: list(
+          object("transactionMessageParsedAccountKey", {
+            pubkey: string(),
+            signer: boolean(),
+            source: string(),
+            writable: boolean()
+          })
+        ),
+        addressTableLookups: list(type(addressTableLookup())),
+        format: string(),
+        header: object("TransactionJsonTransactionHeader", {
+          numReadonlySignedAccounts: number(),
+          numReadonlyUnsignedAccounts: number(),
+          numRequiredSignatures: number()
+        }),
+        instructions: list(type(parsedTransactionInstructionInterface())),
+        recentBlockhash: string()
       },
-      name: "TransactionMessage",
-      resolveType(message) {
-        if (message.format === "parsed") {
-          return "TransactionMessageParsed";
-        }
-        return "TransactionMessageUnparsed";
-      }
+      name: "TransactionMessage"
     });
-  return memoisedTransactionMessageInterface;
-};
-var transactionMessageType = (name, description, accountKeys, instructions) => new graphql.GraphQLObjectType({
-  description,
-  fields: {
-    ...transactionMessageInterfaceFields(),
-    accountKeys,
-    instructions
-  },
-  interfaces: [transactionMessageInterface()],
-  name
-});
-var memoisedTransactionMessageUnparsed;
-var transactionMessageUnparsed = () => {
-  if (!memoisedTransactionMessageUnparsed)
-    memoisedTransactionMessageUnparsed = transactionMessageType(
-      "TransactionMessageUnparsed",
-      "Non-parsed transaction message",
-      list(string()),
-      list(type(transactionInstruction()))
-    );
-  return memoisedTransactionMessageUnparsed;
-};
-var memoisedTransactionMessageParsed;
-var transactionMessageParsed = () => {
-  if (!memoisedTransactionMessageParsed)
-    memoisedTransactionMessageParsed = transactionMessageType(
-      "TransactionMessageParsed",
-      "Parsed transaction message",
-      list(
-        object("transactionMessageParsedAccountKey", {
-          pubkey: string(),
-          signer: boolean(),
-          source: string(),
-          writable: boolean()
-        })
-      ),
-      list(type(parsedTransactionInstructionInterface()))
-    );
-  return memoisedTransactionMessageParsed;
+  return memoisedTransactionMessage;
 };
 var memoisedTransactionTransaction;
 var transactionTransaction = () => {
   if (!memoisedTransactionTransaction)
     memoisedTransactionTransaction = new graphql.GraphQLObjectType({
       fields: {
-        message: type(transactionMessageInterface()),
+        message: type(transactionMessage()),
         signatures: list(string())
       },
       name: "TransactionTransaction"
@@ -1971,8 +4850,6 @@ var transactionTypes = () => {
       ...parsedInstructionsVote(),
       transactionMetaUnparsed(),
       transactionMetaParsed(),
-      transactionMessageUnparsed(),
-      transactionMessageParsed(),
       transactionBase58(),
       transactionBase64(),
       transactionJson(),
@@ -2138,15 +5015,6 @@ var blockQuery = () => ({
     type: blockInterface()
   }
 });
-var programAccount = () => new graphql.GraphQLObjectType({
-  fields: {
-    account: type(accountInterface()),
-    pubkey: string()
-  },
-  name: "ProgramAccount"
-});
-
-// src/schema/program-accounts/query.ts
 var programAccountsQuery = () => ({
   programAccounts: {
     args: {
@@ -2159,7 +5027,7 @@ var programAccountsQuery = () => ({
       withContext: string()
     },
     resolve: (_parent, args, context) => context.resolveProgramAccounts(args),
-    type: new graphql.GraphQLList(programAccount())
+    type: new graphql.GraphQLList(accountInterface())
   }
 });