@solana/rpc-graphql 2.0.0-experimental.a9e6db3 → 2.0.0-experimental.b755749

package/dist/index.node.cjs

@@ -36,7 +36,19 @@ function createGraphQLCache() {
 }
 
 // src/context.ts
-async function resolveAccount({ address, encoding = "jsonParsed", ...config }, cache, rpc) {
+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,11 +58,14 @@ 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 = {
     ...account,
+    address,
     data,
     encoding: responseEncoding
   };
@@ -84,13 +99,14 @@ 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 };
+  const queryResponse = programAccounts.map((programAccount) => {
+    const [data, responseEncoding] = Array.isArray(programAccount.account.data) ? encoding === "jsonParsed" ? [programAccount.account.data[0], "base64"] : [programAccount.account.data[0], encoding] : [programAccount.account.data, "jsonParsed"];
+    const pubkey = programAccount.pubkey;
     return {
-      account,
-      pubkey
+      ...programAccount.account,
+      address: pubkey,
+      data,
+      encoding: responseEncoding
     };
   });
   cache.insert(programAddress, requestConfig, queryResponse);
@@ -125,8 +141,8 @@ 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 +284,7 @@ var dataSliceInputType = () => {
         length: number(),
         offset: number()
       },
-      name: "DataSliceConfig"
+      name: "DataSlice"
     });
   return memoisedDataSliceInputType;
 };
@@ -343,6 +359,7 @@ var memoisedAccountInterfaceFields;
 var accountInterfaceFields = () => {
   if (!memoisedAccountInterfaceFields) {
     memoisedAccountInterfaceFields = {
+      address: string(),
       encoding: string(),
       executable: boolean(),
       lamports: bigint(),
@@ -402,6 +419,7 @@ var accountType = (name, description, data) => new graphql.GraphQLObjectType({
   fields: {
     ...accountInterfaceFields(),
     data,
+    // Nested Account interface
     owner: {
       args: {
         commitment: type(commitmentInputType()),
@@ -409,7 +427,7 @@ var accountType = (name, description, data) => new graphql.GraphQLObjectType({
         encoding: type(accountEncodingInputType()),
         minContextSlot: bigint()
       },
-      resolve: (parent, args, context) => context.resolveAccount({ ...args, address: parent.owner }),
+      resolve: (parent, args, context, info) => context.resolveAccount({ ...args, address: parent.owner }, info),
       type: accountInterface()
     }
   },
@@ -453,7 +471,18 @@ var accountNonceAccount = () => {
       "NonceAccount",
       "A nonce account",
       accountDataJsonParsed("Nonce", {
-        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()
+        },
         blockhash: string(),
         feeCalculator: object("NonceFeeCalculator", {
           lamportsPerSignature: string()
@@ -470,7 +499,18 @@ var accountLookupTable = () => {
       "An address lookup table account",
       accountDataJsonParsed("LookupTable", {
         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()
@@ -488,7 +528,18 @@ var accountMint = () => {
         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()
       })
     );
@@ -503,7 +554,18 @@ var accountTokenAccount = () => {
       accountDataJsonParsed("TokenAccount", {
         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())
       })
@@ -519,11 +581,44 @@ var accountStakeAccount = () => {
       accountDataJsonParsed("Stake", {
         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,7 +630,18 @@ 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()
           })
         })
@@ -552,11 +658,33 @@ var accountVoteAccount = () => {
       accountDataJsonParsed("Vote", {
         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 +697,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(
@@ -609,7 +748,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 +759,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 +1202,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 +1390,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 +1427,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 +1759,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 +1998,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 +2996,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 +3021,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 +3674,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 +4067,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;
@@ -2138,15 +5001,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 +5013,7 @@ var programAccountsQuery = () => ({
       withContext: string()
     },
     resolve: (_parent, args, context) => context.resolveProgramAccounts(args),
-    type: new graphql.GraphQLList(programAccount())
+    type: new graphql.GraphQLList(accountInterface())
   }
 });