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

package/dist/types/renderers/js/GetJavaScriptRenderMapVisitor.d.ts

@@ -1,7 +1,7 @@
 import type { ConfigureOptions } from 'nunjucks';
 import { Options as PrettierOptions } from 'prettier';
 import * as nodes from '../../nodes';
-import { Visitor, BaseThrowVisitor, ResolvedInstructionAccount, Dependency } from '../../visitors';
+import { Visitor, BaseThrowVisitor, Dependency, ResolvedInstructionAccount } from '../../visitors';
 import { RenderMap } from '../RenderMap';
 import { JavaScriptTypeManifest } from './GetJavaScriptTypeManifestVisitor';
 import { JavaScriptImportMap } from './JavaScriptImportMap';
@@ -11,12 +11,16 @@ export type GetJavaScriptRenderMapOptions = {
     dependencyMap?: Record<Dependency, string>;
     typeManifestVisitor?: Visitor<JavaScriptTypeManifest> & {
         setImportStrategy: (importStrategy: 'all' | 'looseOnly' | 'strictOnly') => void;
+        setDefinedName: (definedName: {
+            strict: string;
+            loose: string;
+        } | null) => void;
     };
 };
 export declare class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
     readonly options: Required<GetJavaScriptRenderMapOptions>;
     private program;
-    private resolvedInstructionAccountVisitor;
+    private resolvedInstructionInputVisitor;
     constructor(options?: GetJavaScriptRenderMapOptions);
     visitRoot(root: nodes.RootNode): RenderMap;
     visitProgram(program: nodes.ProgramNode): RenderMap;
@@ -25,6 +29,10 @@ export declare class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<Rend
     visitDefinedType(definedType: nodes.DefinedTypeNode): RenderMap;
     get typeManifestVisitor(): Visitor<JavaScriptTypeManifest> & {
         setImportStrategy: (importStrategy: "all" | "looseOnly" | "strictOnly") => void;
+        setDefinedName: (definedName: {
+            strict: string;
+            loose: string;
+        } | null) => void;
     };
     protected getInstructionAccountType(account: ResolvedInstructionAccount): string;
     protected getInstructionAccountImports(accounts: ResolvedInstructionAccount[]): JavaScriptImportMap;

package/dist/types/renderers/js/GetJavaScriptTypeManifestVisitor.d.ts

@@ -14,6 +14,7 @@ export declare class GetJavaScriptTypeManifestVisitor implements Visitor<JavaScr
     private definedName;
     constructor(serializerVariable?: string);
     setImportStrategy(strategy: GetJavaScriptTypeManifestVisitor['importStrategy']): void;
+    setDefinedName(definedName: GetJavaScriptTypeManifestVisitor['definedName']): void;
     visitRoot(): JavaScriptTypeManifest;
     visitProgram(): JavaScriptTypeManifest;
     visitAccount(account: nodes.AccountNode): JavaScriptTypeManifest;

package/dist/types/visitors/aggregators/GetResolvedInstructionInputsVisitor.d.ts

@@ -0,0 +1,41 @@
+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 declare class GetResolvedInstructionInputsVisitor extends BaseThrowVisitor<ResolvedInstructionInput[]> {
+    protected stack: InstructionNodeInput[];
+    protected resolved: ResolvedInstructionInput[];
+    protected visitedAccounts: Map<string, ResolvedInstructionAccount>;
+    protected visitedArgs: Map<string, ResolvedInstructionArg>;
+    protected error: string | null;
+    getError(): string | null;
+    visitInstruction(instruction: nodes.InstructionNode): ResolvedInstructionInput[];
+    resolveInstructionInput(instruction: nodes.InstructionNode, input: InstructionNodeInput): void;
+    resolveInstructionAccount(instruction: nodes.InstructionNode, account: nodes.InstructionNodeAccount & {
+        kind: 'account';
+    }): ResolvedInstructionAccount;
+    resolveInstructionArg(instruction: nodes.InstructionNode, arg: InstructionNodeArg & {
+        kind: 'arg';
+    }): ResolvedInstructionArg;
+    resolveInstructionDependencies(instruction: nodes.InstructionNode, parent: InstructionNodeInput, dependencies: nodes.InstructionNodeInputDependency[]): void;
+}
+export {};

package/dist/types/visitors/aggregators/index.d.ts

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

package/dist/types/visitors/transformers/UpdateInstructionsVisitor.d.ts

@@ -1,11 +1,12 @@
 import * as nodes from '../../nodes';
+import { Dependency } from '../Dependency';
 import { InstructionNodeAccountDefaultsInput } from './SetInstructionAccountDefaultValuesVisitor';
 import { NodeTransformer, TransformNodesVisitor } from './TransformNodesVisitor';
 export type InstructionUpdates = NodeTransformer<nodes.InstructionNode> | {
     delete: true;
 } | (InstructionMetadataUpdates & {
-    accounts?: InstructionAccountUpdates;
     args?: Record<string, string>;
+    extraArgs?: nodes.TypeStructNode | nodes.TypeDefinedLinkNode | null;
 });
 export type InstructionMetadataUpdates = Partial<Omit<nodes.InstructionNodeMetadata, 'bytesCreatedOnChain'> & {
     bytesCreatedOnChain: InstructionNodeBytesCreatedOnChainInput | null;
@@ -25,8 +26,12 @@ type InstructionNodeBytesCreatedOnChainInput = {
 } | {
     kind: 'account';
     name: string;
-    dependency?: string;
+    dependency?: Dependency;
     includeHeader?: boolean;
+} | {
+    kind: 'resolver';
+    name: string;
+    dependency?: Dependency;
 };
 export declare class UpdateInstructionsVisitor extends TransformNodesVisitor {
     readonly map: Record<string, InstructionUpdates>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metaplex-foundation/kinobi",
-  "version": "0.5.0",
+  "version": "0.7.0-alpha.0",
   "description": "Generate powerful clients for your Solana programs",
   "main": "dist/cjs/index.js",
   "types": "dist/types/index.d.ts",

package/src/idl/IdlInstruction.ts

@@ -17,7 +17,6 @@ export type IdlInstructionAccount = {
   isOptional?: boolean;
   optional?: boolean;
   desc?: string;
-  pdaBumpArg?: string;
 };
 
 export type IdlInstructionArg = {

package/src/nodes/InstructionNode.ts

@@ -17,6 +17,7 @@ export type InstructionNodeMetadata = {
   docs: string[];
   internal: boolean;
   bytesCreatedOnChain: InstructionNodeBytesCreatedOnChain | null;
+  argDefaults: Record<string, InstructionNodeArgDefaults>;
 };
 
 export type InstructionNodeAccount = {
@@ -26,10 +27,28 @@ export type InstructionNodeAccount = {
   isOptional: boolean;
   description: string;
   defaultsTo: InstructionNodeAccountDefaults | null;
-  pdaBumpArg: string | null;
 };
 
+export type InstructionNodeInputDependency = {
+  kind: 'account' | 'arg';
+  name: string;
+};
+
+export type InstructionNodeArgDefaults =
+  | { kind: 'arg'; name: string }
+  | { kind: 'account'; name: string }
+  | { kind: 'accountBump'; name: string }
+  | { kind: 'value'; value: ValueNode }
+  | {
+      kind: 'resolver';
+      name: string;
+      dependency: Dependency;
+      dependsOn: InstructionNodeInputDependency[];
+    };
+
 export type InstructionNodeAccountDefaults =
+  | { kind: 'programId' }
+  | { kind: 'program'; program: { name: string; publicKey: string } }
   | { kind: 'publicKey'; publicKey: string }
   | { kind: 'account'; name: string }
   | { kind: 'identity' }
@@ -40,8 +59,14 @@ export type InstructionNodeAccountDefaults =
       dependency: Dependency;
       seeds: Record<string, InstructionNodeAccountDefaultsSeed>;
     }
-  | { kind: 'program'; program: { name: string; publicKey: string } }
-  | { kind: 'programId' };
+  | {
+      kind: 'resolver';
+      name: string;
+      dependency: Dependency;
+      resolvedIsSigner: boolean | 'either';
+      resolvedIsOptional: boolean;
+      dependsOn: InstructionNodeInputDependency[];
+    };
 
 export type InstructionNodeAccountDefaultsSeed =
   | { kind: 'account'; name: string }
@@ -54,9 +79,10 @@ export type InstructionNodeBytesCreatedOnChain =
   | {
       kind: 'account';
       name: string;
-      dependency: string;
+      dependency: Dependency;
       includeHeader: boolean;
-    };
+    }
+  | { kind: 'resolver'; name: string; dependency: Dependency };
 
 export class InstructionNode implements Visitable {
   readonly nodeClass = 'InstructionNode' as const;
@@ -67,12 +93,15 @@ export class InstructionNode implements Visitable {
 
   readonly args: TypeStructNode | TypeDefinedLinkNode;
 
+  readonly extraArgs: TypeStructNode | TypeDefinedLinkNode | null;
+
   readonly subInstructions: InstructionNode[];
 
   constructor(
     metadata: InstructionNodeMetadata,
     accounts: InstructionNodeAccount[],
     args: InstructionNode['args'],
+    extraArgs: InstructionNode['extraArgs'],
     subInstructions: InstructionNode[]
   ) {
     const bytes = metadata.bytesCreatedOnChain;
@@ -83,6 +112,21 @@ export class InstructionNode implements Visitable {
         bytes && 'name' in bytes
           ? { ...bytes, name: mainCase(bytes.name) }
           : bytes,
+      argDefaults: Object.fromEntries(
+        Object.entries(metadata.argDefaults).map(([key, value]) => {
+          const newValue = { ...value };
+          if ('name' in newValue) {
+            newValue.name = mainCase(newValue.name);
+          }
+          if (newValue.kind === 'resolver') {
+            newValue.dependsOn = newValue.dependsOn.map((dep) => ({
+              ...dep,
+              name: mainCase(dep.name),
+            }));
+          }
+          return [mainCase(key), newValue];
+        })
+      ),
     };
     this.accounts = accounts.map((account) => {
       const { defaultsTo } = account;
@@ -100,10 +144,17 @@ export class InstructionNode implements Visitable {
               : { ...seed, name: mainCase(seed.name) },
           ])
         );
+      } else if (defaultsTo?.kind === 'resolver') {
+        defaultsTo.name = mainCase(defaultsTo.name);
+        defaultsTo.dependsOn = defaultsTo.dependsOn.map((dep) => ({
+          ...dep,
+          name: mainCase(dep.name),
+        }));
       }
       return { ...account, name: mainCase(account.name), defaultsTo };
     });
     this.args = args;
+    this.extraArgs = extraArgs;
     this.subInstructions = subInstructions;
   }
 
@@ -118,6 +169,7 @@ export class InstructionNode implements Visitable {
       docs: idl.docs ?? [],
       internal: false,
       bytesCreatedOnChain: null,
+      argDefaults: {},
     };
 
     const accounts = (idl.accounts ?? []).map(
@@ -135,7 +187,6 @@ export class InstructionNode implements Visitable {
             isOptional && useProgramIdForOptionalAccounts
               ? { kind: 'programId' }
               : null,
-          pdaBumpArg: account.pdaBumpArg ?? null,
         };
       }
     );
@@ -164,7 +215,7 @@ export class InstructionNode implements Visitable {
       ]);
     }
 
-    return new InstructionNode(metadata, accounts, args, []);
+    return new InstructionNode(metadata, accounts, args, null, []);
   }
 
   accept<T>(visitor: Visitor<T>): T {
@@ -186,20 +237,16 @@ export class InstructionNode implements Visitable {
     return this.metadata.docs;
   }
 
-  get isLinked(): boolean {
+  get hasLinkedArgs(): boolean {
     return isTypeDefinedLinkNode(this.args);
   }
 
-  get hasAccounts(): boolean {
-    return this.accounts.length > 0;
-  }
-
-  get pdaAccounts(): InstructionNodeAccount[] {
-    return this.accounts.filter((account) => account.pdaBumpArg !== null);
+  get hasLinkedExtraArgs(): boolean {
+    return isTypeDefinedLinkNode(this.extraArgs);
   }
 
-  get hasPdaAccounts(): boolean {
-    return this.pdaAccounts.length > 0;
+  get hasAccounts(): boolean {
+    return this.accounts.length > 0;
   }
 
   get hasData(): boolean {
@@ -215,12 +262,43 @@ export class InstructionNode implements Visitable {
     return nonOmittedFields.length > 0;
   }
 
-  get hasRequiredArgs(): boolean {
-    if (isTypeDefinedLinkNode(this.args)) return true;
-    const requiredFields = this.args.fields.filter(
-      (field) => field.metadata.defaultsTo === null
+  get hasExtraArgs(): boolean {
+    if (isTypeDefinedLinkNode(this.extraArgs)) return true;
+    const nonOmittedFields =
+      this.extraArgs?.fields.filter(
+        (field) => field.metadata.defaultsTo?.strategy !== 'omitted'
+      ) ?? [];
+    return nonOmittedFields.length > 0;
+  }
+
+  get hasAnyArgs(): boolean {
+    return this.hasArgs || this.hasExtraArgs;
+  }
+
+  get hasArgDefaults(): boolean {
+    return Object.keys(this.metadata.argDefaults).length > 0;
+  }
+
+  get hasArgResolvers(): boolean {
+    return Object.values(this.metadata.argDefaults).some(
+      ({ kind }) => kind === 'resolver'
+    );
+  }
+
+  get hasAccountResolvers(): boolean {
+    return this.accounts.some(
+      ({ defaultsTo }) => defaultsTo?.kind === 'resolver'
+    );
+  }
+
+  get hasByteResolver(): boolean {
+    return this.metadata.bytesCreatedOnChain?.kind === 'resolver';
+  }
+
+  get hasResolvers(): boolean {
+    return (
+      this.hasArgResolvers || this.hasAccountResolvers || this.hasByteResolver
     );
-    return requiredFields.length > 0;
   }
 }
 

package/src/renderers/js/GetJavaScriptRenderMapVisitor.ts

@@ -6,9 +6,10 @@ import { camelCase, pascalCase } from '../../utils';
 import {
   Visitor,
   BaseThrowVisitor,
-  GetResolvedInstructionAccountsVisitor,
-  ResolvedInstructionAccount,
+  GetResolvedInstructionInputsVisitor,
   Dependency,
+  ResolvedInstructionInput,
+  ResolvedInstructionAccount,
 } from '../../visitors';
 import { RenderMap } from '../RenderMap';
 import { resolveTemplate } from '../utils';
@@ -38,6 +39,9 @@ export type GetJavaScriptRenderMapOptions = {
     setImportStrategy: (
       importStrategy: 'all' | 'looseOnly' | 'strictOnly'
     ) => void;
+    setDefinedName: (
+      definedName: { strict: string; loose: string } | null
+    ) => void;
   };
 };
 
@@ -46,9 +50,7 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
 
   private program: nodes.ProgramNode | null = null;
 
-  private resolvedInstructionAccountVisitor: Visitor<
-    ResolvedInstructionAccount[]
-  >;
+  private resolvedInstructionInputVisitor: Visitor<ResolvedInstructionInput[]>;
 
   constructor(options: GetJavaScriptRenderMapOptions = {}) {
     super();
@@ -72,8 +74,8 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
       typeManifestVisitor:
         options.typeManifestVisitor ?? new GetJavaScriptTypeManifestVisitor(),
     };
-    this.resolvedInstructionAccountVisitor =
-      new GetResolvedInstructionAccountsVisitor();
+    this.resolvedInstructionInputVisitor =
+      new GetResolvedInstructionInputsVisitor();
   }
 
   visitRoot(root: nodes.RootNode): RenderMap {
@@ -163,7 +165,13 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
         `programs/${camelCase(name)}.ts`,
         this.render('programsPage.njk', {
           imports: new JavaScriptImportMap()
-            .add('core', ['Program', 'publicKey'])
+            .add('core', [
+              'ClusterFilter',
+              'Context',
+              'Program',
+              'publicKey',
+              'PublicKey',
+            ])
             .add('errors', [
               `get${pascalCaseName}ErrorFromCode`,
               `get${pascalCaseName}ErrorFromName`,
@@ -299,28 +307,42 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
       'transactionBuilder',
     ]);
 
-    // Accounts.
-    const accounts = instruction
-      .accept(this.resolvedInstructionAccountVisitor)
-      .map((account) => {
-        const hasDefaultValue = !!account.defaultsTo;
-        if (account.defaultsTo?.kind === 'pda') {
-          const { seeds } = account.defaultsTo;
+    // Resolved inputs.
+    const resolvedInputs = instruction
+      .accept(this.resolvedInstructionInputVisitor)
+      .map((input: ResolvedInstructionInput) => {
+        if (input.kind === 'account' && input.defaultsTo?.kind === 'pda') {
+          const { seeds } = input.defaultsTo;
           Object.keys(seeds).forEach((seed: string) => {
             const seedValue = seeds[seed];
             if (seedValue.kind !== 'value') return;
-            const seedManifest = renderJavaScriptValueNode(seedValue.value);
-            (seedValue as any).render = seedManifest.render;
-            imports.mergeWith(seedManifest.imports);
+            const valueManifest = renderJavaScriptValueNode(seedValue.value);
+            (seedValue as any).render = valueManifest.render;
+            imports.mergeWith(valueManifest.imports);
           });
         }
-        return {
-          ...account,
-          type: this.getInstructionAccountType(account),
-          optionalSign: hasDefaultValue || account.isOptional ? '?' : '',
-          hasDefaultValue,
-        };
+        if (input.kind === 'arg' && input.defaultsTo.kind === 'value') {
+          const { defaultsTo } = input;
+          const valueManifest = renderJavaScriptValueNode(defaultsTo.value);
+          (defaultsTo as any).render = valueManifest.render;
+          imports.mergeWith(valueManifest.imports);
+        }
+        return input;
       });
+
+    // Accounts.
+    const accounts = instruction.accounts.map((account) => {
+      const hasDefaultValue = !!account.defaultsTo;
+      const resolvedAccount = resolvedInputs.find(
+        (input) => input.kind === 'account' && input.name === account.name
+      ) as ResolvedInstructionAccount;
+      return {
+        ...resolvedAccount,
+        type: this.getInstructionAccountType(resolvedAccount),
+        optionalSign: hasDefaultValue || account.isOptional ? '?' : '',
+        hasDefaultValue,
+      };
+    });
     imports.mergeWith(this.getInstructionAccountImports(accounts));
     if (accounts.length > 0) {
       imports
@@ -328,16 +350,41 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
         .addAlias('core', 'checkForIsWritableOverride', 'isWritable');
     }
 
-    // Arguments.
-    const typeManifest = instruction.accept(this.typeManifestVisitor);
-    imports.mergeWith(typeManifest.imports);
+    // Args.
+    const argManifest = instruction.accept(this.typeManifestVisitor);
+    imports.mergeWith(argManifest.imports);
     if (!nodes.isTypeDefinedLinkNode(instruction.args) && instruction.hasData) {
       imports.add('core', ['Serializer']);
     }
 
+    // Extra args.
+    let extraArgManifest: JavaScriptTypeManifest | null = null;
+    if (instruction.extraArgs) {
+      this.typeManifestVisitor.setDefinedName({
+        strict: `${pascalCase(instruction.name)}InstructionExtra`,
+        loose: `${pascalCase(instruction.name)}InstructionExtraArgs`,
+      });
+      if (nodes.isTypeDefinedLinkNode(instruction.extraArgs)) {
+        this.typeManifestVisitor.setImportStrategy('looseOnly');
+      }
+      extraArgManifest = instruction.extraArgs.accept(this.typeManifestVisitor);
+      this.typeManifestVisitor.setDefinedName(null);
+      this.typeManifestVisitor.setImportStrategy('all');
+      imports.mergeWith(extraArgManifest.imports);
+    }
+
+    // Arg defaults.
+    const argDefaultKeys = Object.keys(instruction.metadata.argDefaults);
+    const argDefaults = Object.values(instruction.metadata.argDefaults);
+    argDefaults.forEach((argDefault) => {
+      if (argDefault.kind === 'resolver') {
+        imports.add(argDefault.dependency, camelCase(argDefault.name));
+      }
+    });
+
     // Bytes created on chain.
     const bytes = instruction.metadata.bytesCreatedOnChain;
-    if (bytes && bytes.includeHeader) {
+    if (bytes && 'includeHeader' in bytes && bytes.includeHeader) {
       imports.add('core', 'ACCOUNT_HEADER_SIZE');
     }
     if (bytes?.kind === 'account') {
@@ -347,6 +394,8 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
           ? 'generatedAccounts'
           : bytes.dependency;
       imports.add(dependency, `get${accountName}Size`);
+    } else if (bytes?.kind === 'resolver') {
+      imports.add(bytes.dependency, camelCase(bytes.name));
     }
 
     // Remove imports from the same module.
@@ -358,7 +407,10 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
 
     // canMergeAccountsAndArgs
     let canMergeAccountsAndArgs = false;
-    if (!nodes.isTypeDefinedLinkNode(instruction.args)) {
+    if (
+      !nodes.isTypeDefinedLinkNode(instruction.args) &&
+      !nodes.isTypeDefinedLinkNode(instruction.extraArgs)
+    ) {
       const accountsAndArgsConflicts =
         this.getMergeConflictsForInstructionAccountsAndArgs(instruction);
       if (accountsAndArgsConflicts.length > 0) {
@@ -374,17 +426,25 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
       canMergeAccountsAndArgs = accountsAndArgsConflicts.length === 0;
     }
 
+    const hasAccountDefaultKinds = (
+      kinds: Array<nodes.InstructionNodeAccountDefaults['kind']>
+    ) =>
+      accounts.some((a) => a.defaultsTo && kinds.includes(a.defaultsTo.kind));
+
     return new RenderMap().add(
       `instructions/${camelCase(instruction.name)}.ts`,
       this.render('instructionsPage.njk', {
         instruction,
         imports: imports.toString(this.options.dependencyMap),
         program: this.program,
+        resolvedInputs,
         accounts,
-        needsEddsa: accounts.some((a) => a.defaultsTo?.kind === 'pda'),
-        needsIdentity: accounts.some((a) => a.defaultsTo?.kind === 'identity'),
-        needsPayer: accounts.some((a) => a.defaultsTo?.kind === 'payer'),
-        typeManifest,
+        needsEddsa: hasAccountDefaultKinds(['pda', 'resolver']),
+        needsIdentity: hasAccountDefaultKinds(['identity', 'resolver']),
+        needsPayer: hasAccountDefaultKinds(['payer', 'resolver']),
+        argDefaultKeys,
+        argManifest,
+        extraArgManifest,
         canMergeAccountsAndArgs,
       })
     );
@@ -417,7 +477,7 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
   protected getInstructionAccountType(
     account: ResolvedInstructionAccount
   ): string {
-    if (account.pdaBumpArg) return 'Pda';
+    if (account.isPda && account.isSigner === false) return 'Pda';
     if (account.isSigner === 'either') return 'PublicKey | Signer';
     return account.isSigner ? 'Signer' : 'PublicKey';
   }
@@ -427,13 +487,12 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
   ): JavaScriptImportMap {
     const imports = new JavaScriptImportMap();
     accounts.forEach((account) => {
-      if (account.pdaBumpArg) {
+      if (account.isPda && account.isSigner === false) {
         imports.add('core', 'Pda');
       }
       if (account.defaultsTo?.kind === 'publicKey') {
         imports.add('core', 'publicKey');
-      }
-      if (account.defaultsTo?.kind === 'pda') {
+      } else if (account.defaultsTo?.kind === 'pda') {
         const pdaAccount = pascalCase(account.defaultsTo.pdaAccount);
         const dependency =
           account.defaultsTo.dependency === 'generated'
@@ -445,6 +504,11 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
             imports.add('core', 'publicKey');
           }
         });
+      } else if (account.defaultsTo?.kind === 'resolver') {
+        imports.add(
+          account.defaultsTo.dependency,
+          camelCase(account.defaultsTo.name)
+        );
       }
       if (account.resolvedIsSigner === 'either') {
         imports.add('core', ['PublicKey', 'publicKey', 'Signer', 'isSigner']);
@@ -461,9 +525,14 @@ export class GetJavaScriptRenderMapVisitor extends BaseThrowVisitor<RenderMap> {
     instruction: nodes.InstructionNode
   ): string[] {
     nodes.assertTypeStructNode(instruction.args);
+    let extraArgsFields: nodes.TypeStructFieldNode[] = [];
+    if (nodes.isTypeStructNode(instruction.extraArgs)) {
+      extraArgsFields = instruction.extraArgs.fields;
+    }
     const allNames = [
       ...instruction.accounts.map((account) => account.name),
       ...instruction.args.fields.map((field) => field.name),
+      ...extraArgsFields.map((field) => field.name),
     ];
     const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
     return [...new Set(duplicates)];

package/src/renderers/js/GetJavaScriptTypeManifestVisitor.ts

@@ -31,6 +31,12 @@ export class GetJavaScriptTypeManifestVisitor
     this.importStrategy = strategy;
   }
 
+  setDefinedName(
+    definedName: GetJavaScriptTypeManifestVisitor['definedName']
+  ): void {
+    this.definedName = definedName;
+  }
+
   visitRoot(): JavaScriptTypeManifest {
     throw new Error(
       'Cannot get type manifest for root node. Please select a child node.'

package/src/renderers/js/GetJavaScriptValidatorBagVisitor.ts

@@ -86,6 +86,8 @@ export class GetJavaScriptValidatorBagVisitor extends GetDefaultValidatorBagVisi
           [`${pascalCaseName}InstructionData`]: 'type',
           [`${pascalCaseName}InstructionDataArgs`]: 'type',
           [`get${pascalCaseName}InstructionDataSerializer`]: 'function',
+          [`${pascalCaseName}InstructionExtraArgs`]: 'type',
+          [`${pascalCaseName}InstructionArgs`]: 'type',
         }),
       ]);
     }