@metaplex-foundation/kinobi 0.0.1

package/src/visitors/transformers/UpdateInstructionsVisitor.ts

@@ -0,0 +1,135 @@
+import * as nodes from '../../nodes';
+import { mainCase } from '../../utils';
+import { InstructionNodeAccountDefaultsInput } from './SetInstructionAccountDefaultValuesVisitor';
+import {
+  NodeTransform,
+  NodeTransformer,
+  TransformNodesVisitor,
+} from './TransformNodesVisitor';
+import { renameStructNode } from './_renameHelpers';
+
+export type InstructionUpdates =
+  | NodeTransformer<nodes.InstructionNode>
+  | { delete: true }
+  | (InstructionMetadataUpdates & {
+      accounts?: InstructionAccountUpdates;
+      args?: Record<string, string>;
+    });
+
+export type InstructionMetadataUpdates = Partial<
+  Omit<nodes.InstructionNodeMetadata, 'bytesCreatedOnChain'> & {
+    bytesCreatedOnChain: InstructionNodeBytesCreatedOnChainInput;
+    accounts: InstructionAccountUpdates;
+  }
+>;
+
+export type InstructionAccountUpdates = Record<
+  string,
+  Partial<
+    Omit<nodes.InstructionNodeAccount, 'defaultsTo'> & {
+      defaultsTo: InstructionNodeAccountDefaultsInput;
+    }
+  >
+>;
+
+type InstructionNodeBytesCreatedOnChainInput =
+  | { kind: 'number'; value: number; includeHeader?: boolean }
+  | { kind: 'arg'; name: string; includeHeader?: boolean }
+  | {
+      kind: 'account';
+      name: string;
+      dependency?: string;
+      includeHeader?: boolean;
+    }
+  | { kind: 'none' };
+
+export class UpdateInstructionsVisitor extends TransformNodesVisitor {
+  protected allAccounts = new Map<string, nodes.AccountNode>();
+
+  constructor(readonly map: Record<string, InstructionUpdates>) {
+    const transforms = Object.entries(map).map(
+      ([selector, updates]): NodeTransform => {
+        const selectorStack = selector.split('.');
+        const name = selectorStack.pop();
+        return {
+          selector: { type: 'instruction', stack: selectorStack, name },
+          transformer: (node, stack, program) => {
+            nodes.assertInstructionNode(node);
+            if (typeof updates === 'function') {
+              return updates(node, stack, program);
+            }
+            if ('delete' in updates) {
+              return null;
+            }
+            const { accounts: accountUpdates, ...metadataUpdates } = updates;
+            const newName = `${mainCase(
+              updates.name ?? node.name
+            )}InstructionArgs`;
+            return new nodes.InstructionNode(
+              { ...node.metadata, ...this.handleMetadata(metadataUpdates) },
+              node.accounts.map((account) =>
+                this.handleInstructionAccount(account, accountUpdates ?? {})
+              ),
+              renameStructNode(node.args, updates.args ?? {}, newName),
+              node.subInstructions
+            );
+          },
+        };
+      }
+    );
+
+    super(transforms);
+  }
+
+  visitRoot(root: nodes.RootNode): nodes.Node | null {
+    root.allAccounts.forEach((account) => {
+      this.allAccounts.set(account.name, account);
+    });
+    return super.visitRoot(root);
+  }
+
+  handleMetadata(
+    metadataUpdates: InstructionMetadataUpdates
+  ): Partial<nodes.InstructionNodeMetadata> {
+    const metadata = metadataUpdates as Partial<nodes.InstructionNodeMetadata>;
+    if (metadata.bytesCreatedOnChain) {
+      metadata.bytesCreatedOnChain = {
+        includeHeader: true,
+        dependency:
+          metadata.bytesCreatedOnChain.kind === 'account'
+            ? 'generated'
+            : undefined,
+        ...metadata.bytesCreatedOnChain,
+      } as nodes.InstructionNodeBytesCreatedOnChain;
+    }
+    return metadata;
+  }
+
+  handleInstructionAccount(
+    account: nodes.InstructionNodeAccount,
+    accountUpdates: InstructionAccountUpdates
+  ): nodes.InstructionNodeAccount {
+    const accountUpdate = accountUpdates?.[account.name];
+
+    if (accountUpdate?.defaultsTo?.kind === 'pda') {
+      const pdaAccount = mainCase(
+        accountUpdate?.defaultsTo?.pdaAccount ?? account.name
+      );
+      return {
+        ...account,
+        defaultsTo: {
+          pdaAccount,
+          dependency: 'generated',
+          seeds:
+            this.allAccounts.get(pdaAccount)?.instructionAccountDefaultSeeds ??
+            {},
+          ...accountUpdate?.defaultsTo,
+        },
+      };
+    }
+
+    return accountUpdate
+      ? ({ ...account, ...accountUpdate } as nodes.InstructionNodeAccount)
+      : account;
+  }
+}

package/src/visitors/transformers/UpdateProgramsVisitor.ts

@@ -0,0 +1,39 @@
+import * as nodes from '../../nodes';
+import {
+  NodeTransform,
+  NodeTransformer,
+  TransformNodesVisitor,
+} from './TransformNodesVisitor';
+
+export type ProgramUpdates =
+  | NodeTransformer<nodes.ProgramNode>
+  | { delete: true }
+  | Partial<nodes.ProgramNodeMetadata>;
+
+export class UpdateProgramsVisitor extends TransformNodesVisitor {
+  constructor(readonly map: Record<string, ProgramUpdates>) {
+    const transforms = Object.entries(map).map(
+      ([name, updates]): NodeTransform => ({
+        selector: { type: 'program', name },
+        transformer: (node, stack, program) => {
+          nodes.assertProgramNode(node);
+          if (typeof updates === 'function') {
+            return updates(node, stack, program);
+          }
+          if ('delete' in updates) {
+            return null;
+          }
+          return new nodes.ProgramNode(
+            { ...node.metadata, ...updates },
+            node.accounts,
+            node.instructions,
+            node.definedTypes,
+            node.errors
+          );
+        },
+      })
+    );
+
+    super(transforms);
+  }
+}

package/src/visitors/transformers/_renameHelpers.ts

@@ -0,0 +1,47 @@
+import * as nodes from '../../nodes';
+
+export function renameStructNode(
+  node: nodes.TypeStructNode,
+  map: Record<string, string>,
+  newName?: string
+): nodes.TypeStructNode {
+  return new nodes.TypeStructNode(
+    newName ?? node.name,
+    node.fields.map((field) =>
+      map[field.name]
+        ? new nodes.TypeStructFieldNode(
+            { ...field.metadata, name: map[field.name] },
+            field.type
+          )
+        : field
+    )
+  );
+}
+
+export function renameEnumNode(
+  node: nodes.TypeEnumNode,
+  map: Record<string, string>,
+  newName?: string
+): nodes.TypeEnumNode {
+  return new nodes.TypeEnumNode(
+    newName ?? node.name,
+    node.variants.map((variant) =>
+      map[variant.name]
+        ? renameEnumVariant(variant, map[variant.name])
+        : variant
+    )
+  );
+}
+
+function renameEnumVariant(
+  variant: nodes.TypeEnumVariantNode,
+  newName: string
+) {
+  if (nodes.isTypeEnumStructVariantNode(variant)) {
+    return new nodes.TypeEnumStructVariantNode(newName, variant.struct);
+  }
+  if (nodes.isTypeEnumTupleVariantNode(variant)) {
+    return new nodes.TypeEnumTupleVariantNode(newName, variant.tuple);
+  }
+  return new nodes.TypeEnumEmptyVariantNode(newName);
+}

package/src/visitors/transformers/index.ts

@@ -0,0 +1,22 @@
+export * from './AutoSetAnchorDiscriminatorsVisitor';
+export * from './AutoSetFixedAccountSizesVisitor';
+export * from './CreateSubInstructionsFromEnumArgsVisitor';
+export * from './DeduplicateIdenticalDefinedTypesVisitor';
+export * from './DeleteNodesVisitor';
+export * from './SetAccountDiscriminatorFromFieldVisitor';
+export * from './SetInstructionAccountDefaultValuesVisitor';
+export * from './SetInstructionDiscriminatorsVisitor';
+export * from './SetLeafWrappersVisitor';
+export * from './SetMissingDefinedTypesVisitor';
+export * from './SetStructDefaultValuesVisitor';
+export * from './TransformNodesVisitor';
+export * from './TransformU8ArraysToBytesVisitor';
+export * from './UnwrapDefinedTypesVisitor';
+export * from './UnwrapInstructionArgsDefinedTypesVisitor';
+export * from './UnwrapInstructionArgsStructVisitor';
+export * from './UnwrapStructVisitor';
+export * from './UpdateAccountsVisitor';
+export * from './UpdateDefinedTypesVisitor';
+export * from './UpdateErrorsVisitor';
+export * from './UpdateInstructionsVisitor';
+export * from './UpdateProgramsVisitor';

package/src/visitors/workers/ConsoleLogVisitor.ts

@@ -0,0 +1,8 @@
+import { BaseDelegateVisitor } from '../BaseDelegateVisitor';
+
+export class ConsoleLogVisitor extends BaseDelegateVisitor<any, void> {
+  map(value: any): void {
+    // eslint-disable-next-line no-console
+    console.log(value);
+  }
+}

package/src/visitors/workers/ThrowValidatorItemsVisitor.ts

@@ -0,0 +1,42 @@
+/* eslint-disable no-console */
+import chalk from 'chalk';
+import { getLevelIndex, LogLevel } from '../../logs';
+import { BaseDelegateVisitor } from '../BaseDelegateVisitor';
+import { ValidatorBag } from '../ValidatorBag';
+import { Visitor } from '../Visitor';
+
+export class ThrowValidatorItemsVisitor extends BaseDelegateVisitor<
+  ValidatorBag,
+  void
+> {
+  constructor(
+    validator: Visitor<ValidatorBag>,
+    readonly throwLevel: LogLevel = 'error'
+  ) {
+    super(validator);
+  }
+
+  map(validatorBag: ValidatorBag): void {
+    const bag = validatorBag.orderByLevel();
+    bag.log();
+
+    const levelHistogram = bag.items.reduce((acc, item) => {
+      acc[item.level] = (acc[item.level] ?? 0) + 1;
+      return acc;
+    }, {} as Record<LogLevel, number>);
+    const maxLevel = Object.keys(levelHistogram)
+      .map((level) => getLevelIndex(level as LogLevel))
+      .sort((a, b) => b - a)[0];
+
+    if (maxLevel >= getLevelIndex(this.throwLevel)) {
+      const histogramString = Object.keys(levelHistogram)
+        .map((level) => `${level}s: ${levelHistogram[level as LogLevel]}`)
+        .join(', ');
+      console.log(
+        `${chalk.red(`Failed to validate the nodes.`)} ` +
+          `${chalk.red.bold(`Found ${histogramString}.`)}\n`
+      );
+      process.exit(1);
+    }
+  }
+}

package/src/visitors/workers/index.ts

@@ -0,0 +1,2 @@
+export * from './ConsoleLogVisitor';
+export * from './ThrowValidatorItemsVisitor';