@metaplex-foundation/kinobi 0.6.0 → 0.7.0-alpha.0

package/src/renderers/js/templates/instructionsPageAccountMetas.njk

@@ -1,62 +1,19 @@
-{% if accounts.length > 0 %}
-  // Resolved accounts.
-  {% for account in accounts | sort(false, false, 'dependencyPosition') %}
-    {% if not account.defaultsTo %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }};
-    {% elif account.defaultsTo.kind === 'account' %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }} ?? {{ account.defaultsTo.name | camelCase }}Account;
-    {% elif account.defaultsTo.kind === 'pda' %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }} ?? find{{ account.defaultsTo.pdaAccount | pascalCase }}Pda(context,
-      {%- if (account.defaultsTo.seeds | length) > 0 -%}
-        {
-          {%- for seedKey, seedValue in account.defaultsTo.seeds -%}
-            {%- if seedValue.kind === 'value' -%}
-              {{ seedKey }}: {{ seedValue.render }},
-            {%- elif seedValue.kind === 'account' -%}
-              {{ seedKey }}: publicKey({{ seedValue.name | camelCase }}Account),
-            {%- else -%}
-              {{ seedKey }}: {{ argsObj }}.{{ seedValue.name | camelCase }},
-            {%- endif -%}
-          {%- endfor -%}
-        }
-      {%- endif -%}
-      );
-    {% elif account.defaultsTo.kind === 'publicKey' %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }} ?? publicKey('{{ account.defaultsTo.publicKey }}');
-    {% elif account.defaultsTo.kind === 'program' %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }} ?? { ...context.programs.getPublicKey('{{ account.defaultsTo.program.name }}', '{{ account.defaultsTo.program.publicKey }}'), isWritable: false };
-    {% elif account.defaultsTo.kind === 'programId' %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }} ?? { ...programId, isWritable: false };
-    {% elif account.defaultsTo.kind === 'identity' and (account.isSigner !== false) %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }} ?? context.identity;
-    {% elif account.defaultsTo.kind === 'identity' %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }} ?? context.identity.publicKey;
-    {% elif account.defaultsTo.kind === 'payer' and (account.isSigner !== false) %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }} ?? context.payer;
-    {% elif account.defaultsTo.kind === 'payer' %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }} ?? context.payer.publicKey;
-    {% else %}
-      const {{ account.name | camelCase }}Account = {{ accountsObj }}.{{ account.name | camelCase }};
-    {% endif %}
-  {% endfor %}
-{% endif %}
-
-{% for account in accounts | sort(false, false, 'position') %}
+{% for account in accounts %}
   {% set isWritableString = 'true' if account.isWritable else 'false' %}
   // {{ account.name | camelCase | titleCase }}{% if account.resolvedIsOptional %} (optional){% endif %}.
   {% if account.resolvedIsOptional %}
-  if ({{ account.name | camelCase }}Account) {
+  if (resolvedAccounts.{{ account.name | camelCase }}) {
   {% endif %}
     {% if account.resolvedIsSigner === 'either' %}
-      if (isSigner({{ account.name | camelCase }}Account)) {
-        signers.push({{ account.name | camelCase }}Account);
+      if (isSigner(resolvedAccounts.{{ account.name | camelCase }})) {
+        signers.push(resolvedAccounts.{{ account.name | camelCase }});
       }
-      keys.push({ pubkey: publicKey({{ account.name | camelCase }}Account), isSigner: isSigner({{ account.name | camelCase }}Account), isWritable: isWritable({{ account.name | camelCase }}Account, {{ isWritableString }}) });
+      keys.push({ pubkey: publicKey(resolvedAccounts.{{ account.name | camelCase }}), isSigner: isSigner(resolvedAccounts.{{ account.name | camelCase }}), isWritable: isWritable(resolvedAccounts.{{ account.name | camelCase }}, {{ isWritableString }}) });
     {% elif account.resolvedIsSigner  %}
-      signers.push({{ account.name | camelCase }}Account);
-      keys.push({ pubkey: {{ account.name | camelCase }}Account.publicKey, isSigner: true, isWritable: isWritable({{ account.name | camelCase }}Account, {{ isWritableString }}) });
+      signers.push(resolvedAccounts.{{ account.name | camelCase }});
+      keys.push({ pubkey: resolvedAccounts.{{ account.name | camelCase }}.publicKey, isSigner: true, isWritable: isWritable(resolvedAccounts.{{ account.name | camelCase }}, {{ isWritableString }}) });
     {% else %}
-      keys.push({ pubkey: {{ account.name | camelCase }}Account, isSigner: false, isWritable: isWritable({{ account.name | camelCase }}Account, {{ isWritableString }}) });
+      keys.push({ pubkey: resolvedAccounts.{{ account.name | camelCase }}, isSigner: false, isWritable: isWritable(resolvedAccounts.{{ account.name | camelCase }}, {{ isWritableString }}) });
     {% endif %}
   {% if account.resolvedIsOptional %}
   }

package/src/renderers/js/templates/instructionsPageArgs.njk

@@ -1,7 +1,36 @@
-{% if not instruction.isLinked and instruction.hasData %}
-// Arguments.
-{{ macros.exportType(instruction.name | pascalCase + 'InstructionData', typeManifest) }}
+{% if not instruction.hasLinkedArgs and instruction.hasData %}
+  // Data.
+  {{ macros.exportType(instruction.name | pascalCase + 'InstructionData', argManifest) }}
 
-{{ macros.exportSerializer(instruction.name | pascalCase + 'InstructionData', typeManifest) }}
+  {{ macros.exportSerializer(instruction.name | pascalCase + 'InstructionData', argManifest) }}
+{% endif %}
 
-{% endif %}
+{% if not instruction.hasLinkedExtraArgs and instruction.hasExtraArgs %}
+  // Extra Args.
+  export type {{ instruction.name | pascalCase + 'InstructionExtraArgs' }} = {{ extraArgManifest.looseType }};
+{% endif %}
+
+{% if instruction.hasAnyArgs %}
+  {% set argType %}
+    {% if instruction.hasArgs and instruction.hasExtraArgs %}
+      {{ instruction.name | pascalCase + 'InstructionDataArgs' }} & {{ instruction.name | pascalCase + 'InstructionExtraArgs' }}
+    {% elif instruction.hasArgs %}
+      {{ instruction.name | pascalCase + 'InstructionDataArgs' }}
+    {% elif instruction.hasExtraArgs %}
+      {{ instruction.name | pascalCase + 'InstructionExtraArgs' }}
+    {% endif %}
+  {% endset %}
+
+  // Args.
+  {% if argDefaultKeys.length > 0 %}
+    type PickPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+    export type {{ instruction.name | pascalCase + 'InstructionArgs' }} = PickPartial<
+      {{ argType }}, 
+      {% for key in argDefaultKeys %}
+        "{{ key }}"{% if not loop.last %} | {% endif %}
+      {% endfor %}
+    >;
+  {% else %}
+    export type {{ instruction.name | pascalCase + 'InstructionArgs' }} = {{ argType }};
+  {% endif %}
+{% endif %}

package/src/renderers/js/templates/instructionsPageResolvedInputs.njk

@@ -0,0 +1,63 @@
+{% set hasResolvedAccounts = accounts.length > 0 or instruction.hasResolvers %}
+{% set hasResolvedArgs = instruction.hasArgs or instruction.hasArgDefaults or instruction.hasResolvers %}
+
+{% if resolvedInputs.length > 0 or hasResolvedAccounts or hasResolvedArgs %}
+  // Resolved inputs.
+  {% if hasResolvedAccounts %}
+    const resolvedAccounts: any = { ...{{ accountsObj }} };
+  {% endif %}
+  {% if hasResolvedArgs %}
+    const resolvedArgs: any = { ...{{ argsObj }} };
+  {% endif %}
+  {% for input in resolvedInputs %}
+    {% if input.kind === 'account' and input.defaultsTo %}
+      {% if input.defaultsTo.kind === 'account' %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? resolvedAccounts.{{ input.defaultsTo.name | camelCase }};
+      {% elif input.defaultsTo.kind === 'pda' %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? find{{ input.defaultsTo.pdaAccount | pascalCase }}Pda(context,
+        {%- if (input.defaultsTo.seeds | length) > 0 -%}
+          {
+            {%- for seedKey, seedValue in input.defaultsTo.seeds -%}
+              {%- if seedValue.kind === 'value' -%}
+                {{ seedKey }}: {{ seedValue.render }},
+              {%- elif seedValue.kind === 'account' -%}
+                {{ seedKey }}: publicKey(resolvedAccounts.{{ seedValue.name | camelCase }}),
+              {%- else -%}
+                {{ seedKey }}: resolvedArgs.{{ seedValue.name | camelCase }},
+              {%- endif -%}
+            {%- endfor -%}
+          }
+        {%- endif -%}
+        );
+      {% elif input.defaultsTo.kind === 'publicKey' %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? publicKey('{{ input.defaultsTo.publicKey }}');
+      {% elif input.defaultsTo.kind === 'program' %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? { ...context.programs.getPublicKey('{{ input.defaultsTo.program.name }}', '{{ input.defaultsTo.program.publicKey }}'), isWritable: false };
+      {% elif input.defaultsTo.kind === 'programId' %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? programId;
+      {% elif input.defaultsTo.kind === 'identity' and (input.isSigner !== false) %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? context.identity;
+      {% elif input.defaultsTo.kind === 'identity' %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? context.identity.publicKey;
+      {% elif input.defaultsTo.kind === 'payer' and (input.isSigner !== false) %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? context.payer;
+      {% elif input.defaultsTo.kind === 'payer' %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? context.payer.publicKey;
+      {% elif input.defaultsTo.kind === 'resolver' %}
+        resolvedAccounts.{{ input.name | camelCase }} = resolvedAccounts.{{ input.name | camelCase }} ?? {{ input.defaultsTo.name | camelCase }}(context, resolvedAccounts, resolvedArgs, programId);
+      {% endif %}
+    {% elif input.kind === 'arg' %}
+      {% if input.defaultsTo.kind === 'arg' %}
+        resolvedArgs.{{ input.name | camelCase }} = resolvedArgs.{{ input.name | camelCase }} ?? resolvedArgs.{{ input.defaultsTo.name | camelCase }};
+      {% elif input.defaultsTo.kind === 'account' %}
+        resolvedArgs.{{ input.name | camelCase }} = resolvedArgs.{{ input.name | camelCase }} ?? resolvedAccounts.{{ input.defaultsTo.name | camelCase }};
+      {% elif input.defaultsTo.kind === 'accountBump' %}
+        resolvedArgs.{{ input.name | camelCase }} = resolvedArgs.{{ input.name | camelCase }} ?? resolvedAccounts.{{ input.defaultsTo.name | camelCase }}.bump;
+      {% elif input.defaultsTo.kind === 'value' %}
+        resolvedArgs.{{ input.name | camelCase }} = resolvedArgs.{{ input.name | camelCase }} ?? {{ input.defaultsTo.render }};
+      {% elif input.defaultsTo.kind === 'resolver' %}
+        resolvedArgs.{{ input.name | camelCase }} = resolvedArgs.{{ input.name | camelCase }} ?? {{ input.defaultsTo.name | camelCase }}(context, resolvedAccounts, resolvedArgs, programId);
+      {% endif %}
+    {% endif %}
+  {% endfor %}
+{% endif %}

package/src/visitors/BaseNodeOrNullVisitor.ts

@@ -63,10 +63,15 @@ export class BaseNodeOrNullVisitor implements Visitor<nodes.Node | null> {
     const args = instruction.args.accept(this);
     if (args === null) return null;
     nodes.assertTypeStructOrDefinedLinkNode(args);
+    const extraArgs = instruction.extraArgs?.accept(this) ?? null;
+    if (extraArgs !== null) {
+      nodes.assertTypeStructOrDefinedLinkNode(args);
+    }
     return new nodes.InstructionNode(
       instruction.metadata,
       instruction.accounts,
       args,
+      extraArgs as nodes.TypeStructNode | nodes.TypeDefinedLinkNode | null,
       instruction.subInstructions
         .map((ix) => ix.accept(this))
         .filter(

package/src/visitors/BaseNodeVisitor.ts

@@ -51,10 +51,15 @@ export class BaseNodeVisitor implements Visitor<nodes.Node> {
   visitInstruction(instruction: nodes.InstructionNode): nodes.Node {
     const args = instruction.args.accept(this);
     nodes.assertTypeStructOrDefinedLinkNode(args);
+    const extraArgs = instruction.extraArgs?.accept(this) ?? null;
+    if (extraArgs !== null) {
+      nodes.assertTypeStructOrDefinedLinkNode(args);
+    }
     return new nodes.InstructionNode(
       instruction.metadata,
       instruction.accounts,
       args,
+      extraArgs as nodes.TypeStructNode | nodes.TypeDefinedLinkNode | null,
       instruction.subInstructions
         .map((ix) => ix.accept(this))
         .filter(

package/src/visitors/BaseVoidVisitor.ts

@@ -21,6 +21,7 @@ export abstract class BaseVoidVisitor implements Visitor<void> {
 
   visitInstruction(instruction: nodes.InstructionNode): void {
     instruction.args.accept(this);
+    instruction.extraArgs?.accept(this);
     instruction.subInstructions.forEach((ix) => ix.accept(this));
   }
 

package/src/visitors/aggregators/GetDefaultValidatorBagVisitor.ts

@@ -1,8 +1,9 @@
 import * as nodes from '../../nodes';
+import { mainCase } from '../../utils';
 import { NodeStack } from '../NodeStack';
 import { ValidatorBag } from '../ValidatorBag';
 import { Visitor } from '../Visitor';
-import { GetResolvedInstructionAccountsVisitor } from './GetResolvedInstructionAccountsVisitor';
+import { GetResolvedInstructionInputsVisitor } from './GetResolvedInstructionInputsVisitor';
 
 export class GetDefaultValidatorBagVisitor implements Visitor<ValidatorBag> {
   protected stack: NodeStack = new NodeStack();
@@ -84,7 +85,7 @@ export class GetDefaultValidatorBagVisitor implements Visitor<ValidatorBag> {
     });
 
     // Check for cyclic dependencies in account defaults.
-    const cyclicCheckVisitor = new GetResolvedInstructionAccountsVisitor();
+    const cyclicCheckVisitor = new GetResolvedInstructionInputsVisitor();
     try {
       instruction.accept(cyclicCheckVisitor);
     } catch (error) {
@@ -95,8 +96,53 @@ export class GetDefaultValidatorBagVisitor implements Visitor<ValidatorBag> {
       );
     }
 
+    // Check args.
     bag.mergeWith([instruction.args.accept(this)]);
 
+    // Check extra args.
+    if (instruction.extraArgs) {
+      bag.mergeWith([instruction.extraArgs.accept(this)]);
+      if (
+        nodes.isTypeStructNode(instruction.args) &&
+        nodes.isTypeStructNode(instruction.extraArgs)
+      ) {
+        const names = [
+          ...instruction.args.fields.map(({ name }) => mainCase(name)),
+          ...instruction.extraArgs.fields.map(({ name }) => mainCase(name)),
+        ];
+        const duplicates = names.filter((e, i, a) => a.indexOf(e) !== i);
+        const uniqueDuplicates = [...new Set(duplicates)];
+        const hasConflictingNames = uniqueDuplicates.length > 0;
+        if (hasConflictingNames) {
+          bag.error(
+            `The names of the following instruction arguments are conflicting: ` +
+              `[${uniqueDuplicates.join(', ')}].`,
+            instruction,
+            this.stack
+          );
+        }
+      }
+    }
+
+    // Check arg defaults.
+    Object.entries(instruction.metadata.argDefaults).forEach(
+      ([name, defaultsTo]) => {
+        if (defaultsTo.kind === 'accountBump') {
+          const defaultAccount = instruction.accounts.find(
+            (account) => account.name === defaultsTo.name
+          );
+          if (defaultAccount && defaultAccount.isSigner !== false) {
+            bag.error(
+              `Argument ${name} cannot default to the bump attribute of ` +
+                `the [${defaultsTo.name}] account as it may be a Signer.`,
+              instruction,
+              this.stack
+            );
+          }
+        }
+      }
+    );
+
     // Check sub-instructions.
     bag.mergeWith(instruction.subInstructions.map((ix) => ix.accept(this)));
 

package/src/visitors/aggregators/GetNodeInlineStringVisitor.ts

@@ -32,11 +32,12 @@ export class GetNodeInlineStringVisitor implements Visitor<string> {
   visitInstruction(instruction: nodes.InstructionNode): string {
     const accounts = instruction.accounts.map((account) => account.name);
     const args = instruction.args.accept(this);
+    const extraArgs = instruction.extraArgs?.accept(this);
+    const extraArgsString = extraArgs ? `,extraArgs:(${extraArgs})` : '';
     return (
       `${INSTRUCTION_PREFIX}[${instruction.name}](` +
       `accounts:(${accounts.join(',')}),` +
-      `args:(${args})` +
-      `)`
+      `args:(${args})${extraArgsString})`
     );
   }
 

package/src/visitors/aggregators/GetNodeTreeStringVisitor.ts

@@ -91,6 +91,12 @@ export class GetNodeTreeStringVisitor implements Visitor<string> {
     this.indent += 1;
     children.push(instruction.args.accept(this));
     this.indent -= 1;
+    if (instruction.extraArgs) {
+      children.push(this.indented('extra arguments:'));
+      this.indent += 1;
+      children.push(instruction.extraArgs.accept(this));
+      this.indent -= 1;
+    }
     this.indent -= 1;
     return children.join('\n');
   }

package/src/visitors/aggregators/GetResolvedInstructionInputsVisitor.ts

@@ -0,0 +1,275 @@
+import type * as nodes from '../../nodes';
+import { BaseThrowVisitor } from '../BaseThrowVisitor';
+
+type InstructionNodeInput =
+  | ({ kind: 'arg' } & InstructionNodeArg)
+  | ({ kind: 'account' } & nodes.InstructionNodeAccount);
+
+type InstructionNodeArg = {
+  name: string;
+  defaultsTo: nodes.InstructionNodeArgDefaults;
+};
+
+export type ResolvedInstructionAccount = nodes.InstructionNodeAccount & {
+  kind: 'account';
+  isPda: boolean;
+  dependsOn: nodes.InstructionNodeInputDependency[];
+  resolvedIsSigner: boolean | 'either';
+  resolvedIsOptional: boolean;
+};
+
+export type ResolvedInstructionArg = InstructionNodeArg & {
+  kind: 'arg';
+  dependsOn: nodes.InstructionNodeInputDependency[];
+};
+
+export type ResolvedInstructionInput =
+  | ResolvedInstructionAccount
+  | ResolvedInstructionArg;
+
+export class GetResolvedInstructionInputsVisitor extends BaseThrowVisitor<
+  ResolvedInstructionInput[]
+> {
+  protected stack: InstructionNodeInput[] = [];
+
+  protected resolved: ResolvedInstructionInput[] = [];
+
+  protected visitedAccounts = new Map<string, ResolvedInstructionAccount>();
+
+  protected visitedArgs = new Map<string, ResolvedInstructionArg>();
+
+  protected error: string | null = null;
+
+  getError(): string | null {
+    return this.error;
+  }
+
+  visitInstruction(
+    instruction: nodes.InstructionNode
+  ): ResolvedInstructionInput[] {
+    // Ensure we always start with a clean slate.
+    this.error = null;
+    this.stack = [];
+    this.resolved = [];
+    this.visitedAccounts = new Map();
+    this.visitedArgs = new Map();
+
+    const inputs: InstructionNodeInput[] = [
+      ...instruction.accounts.map((account) => ({
+        kind: 'account' as const,
+        ...account,
+      })),
+      ...Object.entries(instruction.metadata.argDefaults).map(
+        ([argName, argDefault]) => ({
+          kind: 'arg' as const,
+          name: argName,
+          defaultsTo: argDefault,
+        })
+      ),
+    ];
+
+    // Visit all instruction accounts.
+    inputs.forEach((input) => {
+      this.resolveInstructionInput(instruction, input);
+    });
+
+    return this.resolved;
+  }
+
+  resolveInstructionInput(
+    instruction: nodes.InstructionNode,
+    input: InstructionNodeInput
+  ): void {
+    // Ensure we don't visit the same input twice.
+    if (
+      (input.kind === 'account' && this.visitedAccounts.has(input.name)) ||
+      (input.kind === 'arg' && this.visitedArgs.has(input.name))
+    ) {
+      return;
+    }
+
+    // Ensure we don't have a circular dependency.
+    const isCircular = this.stack.some(
+      ({ kind, name }) => kind === input.kind && name === input.name
+    );
+    if (isCircular) {
+      const cycle = [...this.stack.map(({ name }) => name), input.name].join(
+        ' -> '
+      );
+      this.error =
+        `Circular dependency detected in the accounts and args of ` +
+        `the "${instruction.name}" instruction. ` +
+        `Got the following dependency cycle: ${cycle}.`;
+      throw new Error(this.error);
+    }
+
+    // Resolve whilst keeping track of the stack.
+    this.stack.push(input);
+    const resolved =
+      input.kind === 'account'
+        ? this.resolveInstructionAccount(instruction, input)
+        : this.resolveInstructionArg(instruction, input);
+    this.stack.pop();
+
+    // Store the resolved input.
+    this.resolved.push(resolved);
+    if (resolved.kind === 'account') {
+      this.visitedAccounts.set(input.name, resolved);
+    } else {
+      this.visitedArgs.set(input.name, resolved);
+    }
+  }
+
+  resolveInstructionAccount(
+    instruction: nodes.InstructionNode,
+    account: nodes.InstructionNodeAccount & { kind: 'account' }
+  ): ResolvedInstructionAccount {
+    // Get account dependencies.
+    const dependsOn: nodes.InstructionNodeInputDependency[] = [];
+    if (account.defaultsTo?.kind === 'account') {
+      dependsOn.push({ kind: 'account', name: account.defaultsTo.name });
+    } else if (account.defaultsTo?.kind === 'pda') {
+      const accounts = new Set<string>();
+      const args = new Set<string>();
+      Object.values(account.defaultsTo.seeds).forEach((seed) => {
+        if (seed.kind === 'account') {
+          accounts.add(seed.name);
+        } else if (seed.kind === 'arg') {
+          args.add(seed.name);
+        }
+      });
+      dependsOn.push(
+        ...[...accounts].map((name) => ({ kind: 'account' as const, name })),
+        ...[...accounts].map((name) => ({ kind: 'arg' as const, name }))
+      );
+    } else if (account.defaultsTo?.kind === 'resolver') {
+      dependsOn.push(...account.defaultsTo.dependsOn);
+    }
+
+    // Visit account dependencies first.
+    this.resolveInstructionDependencies(instruction, account, dependsOn);
+
+    const resolved: ResolvedInstructionAccount = {
+      ...account,
+      isPda: Object.values(instruction.metadata.argDefaults).some(
+        (argDefault) =>
+          argDefault.kind === 'accountBump' && argDefault.name === account.name
+      ),
+      dependsOn,
+      resolvedIsSigner: account.isSigner,
+      resolvedIsOptional: account.isOptional,
+    };
+
+    switch (resolved.defaultsTo?.kind) {
+      case 'account':
+        const defaultAccount = this.visitedAccounts.get(
+          resolved.defaultsTo.name
+        )!;
+        const resolvedIsPublicKey =
+          account.isSigner === false && defaultAccount.isSigner === false;
+        const resolvedIsSigner =
+          account.isSigner === true && defaultAccount.isSigner === true;
+        const resolvedIsOptionalSigner =
+          !resolvedIsPublicKey && !resolvedIsSigner;
+        resolved.resolvedIsSigner = resolvedIsOptionalSigner
+          ? 'either'
+          : resolvedIsSigner;
+        resolved.resolvedIsOptional = defaultAccount.isOptional;
+        break;
+      case 'publicKey':
+      case 'program':
+      case 'programId':
+        resolved.resolvedIsSigner =
+          account.isSigner === false ? false : 'either';
+        resolved.resolvedIsOptional = false;
+        break;
+      case 'pda':
+        resolved.resolvedIsSigner =
+          account.isSigner === false ? false : 'either';
+        resolved.resolvedIsOptional = false;
+        const { seeds } = resolved.defaultsTo;
+        Object.keys(seeds).forEach((seedKey) => {
+          const seed = seeds[seedKey];
+          if (seed.kind !== 'account') return;
+          const dependency = this.visitedAccounts.get(seed.name)!;
+          if (dependency.resolvedIsOptional) {
+            this.error =
+              `Cannot use optional account "${seed.name}" as the "${seedKey}" PDA seed ` +
+              `for the "${account.name}" account of the "${instruction.name}" instruction.`;
+            throw new Error(this.error);
+          }
+        });
+        break;
+      case 'identity':
+      case 'payer':
+        resolved.resolvedIsOptional = false;
+        break;
+      case 'resolver':
+        resolved.resolvedIsOptional = resolved.defaultsTo.resolvedIsOptional;
+        resolved.resolvedIsSigner = resolved.defaultsTo.resolvedIsSigner;
+        break;
+      default:
+        break;
+    }
+
+    return resolved;
+  }
+
+  resolveInstructionArg(
+    instruction: nodes.InstructionNode,
+    arg: InstructionNodeArg & { kind: 'arg' }
+  ): ResolvedInstructionArg {
+    // Get account dependencies.
+    const dependsOn: nodes.InstructionNodeInputDependency[] = [];
+    if (
+      arg.defaultsTo.kind === 'account' ||
+      arg.defaultsTo.kind === 'accountBump'
+    ) {
+      dependsOn.push({ kind: 'account', name: arg.defaultsTo.name });
+    } else if (arg.defaultsTo.kind === 'arg') {
+      dependsOn.push({ kind: 'arg', name: arg.defaultsTo.name });
+    } else if (arg.defaultsTo.kind === 'resolver') {
+      dependsOn.push(...arg.defaultsTo.dependsOn);
+    }
+
+    // Visit account dependencies first.
+    this.resolveInstructionDependencies(instruction, arg, dependsOn);
+
+    return { ...arg, dependsOn };
+  }
+
+  resolveInstructionDependencies(
+    instruction: nodes.InstructionNode,
+    parent: InstructionNodeInput,
+    dependencies: nodes.InstructionNodeInputDependency[]
+  ): void {
+    dependencies.forEach((dependency) => {
+      let input: InstructionNodeInput | null = null;
+      if (dependency.kind === 'account') {
+        const dependencyAccount = instruction.accounts.find(
+          ({ name }) => name === dependency.name
+        );
+        if (!dependencyAccount) {
+          this.error =
+            `Account "${dependency.name}" is not a valid dependency of ${parent.kind} ` +
+            `"${parent.name}" in the "${instruction.name}" instruction.`;
+          throw new Error(this.error);
+        }
+        input = { kind: 'account', ...dependencyAccount };
+      } else if (dependency.kind === 'arg') {
+        const dependencyArg =
+          instruction.metadata.argDefaults[dependency.name] ?? null;
+        if (dependencyArg) {
+          input = {
+            kind: 'arg',
+            name: dependency.name,
+            defaultsTo: dependencyArg,
+          };
+        }
+      }
+      if (input) {
+        this.resolveInstructionInput(instruction, input);
+      }
+    });
+  }
+}

package/src/visitors/aggregators/index.ts

@@ -3,4 +3,4 @@ export * from './GetDefaultValidatorBagVisitor';
 export * from './GetDefinedTypeHistogramVisitor';
 export * from './GetNodeInlineStringVisitor';
 export * from './GetNodeTreeStringVisitor';
-export * from './GetResolvedInstructionAccountsVisitor';
+export * from './GetResolvedInstructionInputsVisitor';

package/src/visitors/transformers/AutoSetAnchorDiscriminatorsVisitor.ts

@@ -86,6 +86,7 @@ export class AutoSetAnchorDiscriminatorsVisitor extends BaseNodeVisitor {
         discriminatorField,
         ...instruction.args.fields,
       ]),
+      instruction.extraArgs,
       instruction.subInstructions
     );
   }

package/src/visitors/transformers/CreateSubInstructionsFromEnumArgsVisitor.ts

@@ -92,6 +92,7 @@ export class CreateSubInstructionsFromEnumArgsVisitor extends TransformNodesVisi
                       subFields
                     )
                   ),
+                  node.extraArgs,
                   []
                 );
               }
@@ -101,6 +102,7 @@ export class CreateSubInstructionsFromEnumArgsVisitor extends TransformNodesVisi
               node.metadata,
               node.accounts,
               node.args,
+              node.extraArgs,
               [...node.subInstructions, ...subInstructions]
             );
           },

package/src/visitors/transformers/FlattenInstructionArgsStructVisitor.ts

@@ -13,6 +13,7 @@ export class FlattenInstructionArgsStructVisitor extends TransformNodesVisitor {
             instruction.metadata,
             instruction.accounts,
             flattenStruct(instruction.args),
+            instruction.extraArgs,
             instruction.subInstructions
           );
         },

package/src/visitors/transformers/SetInstructionAccountDefaultValuesVisitor.ts

@@ -251,6 +251,7 @@ export class SetInstructionAccountDefaultValuesVisitor extends BaseNodeVisitor {
       instruction.metadata,
       instructionAccounts,
       instruction.args,
+      instruction.extraArgs,
       instruction.subInstructions
     );
   }

package/src/visitors/transformers/SetInstructionDiscriminatorsVisitor.ts

@@ -43,6 +43,7 @@ export class SetInstructionDiscriminatorsVisitor extends TransformNodesVisitor {
                 discriminatorField,
                 ...node.args.fields,
               ]),
+              node.extraArgs,
               node.subInstructions
             );
           },