Add InstructionByteDeltaNode (#135)

* Add InstructionByteDeltaNode

* Update templates

* Refactor instructionRemainingAccounts fragment to match the byteDelta fragment

* Add changeset

.changeset/mighty-socks-flash.md

@@ -0,0 +1,5 @@
+---
+'@metaplex-foundation/kinobi': minor
+---
+
+Add InstructionByteDeltaNode

src/nodes/InstructionByteDeltaNode.ts

@@ -0,0 +1,34 @@
+import { isNode } from './Node';
+import { ArgumentValueNode, ResolverValueNode } from './contextualValueNodes';
+import { AccountLinkNode } from './linkNodes';
+import { NumberValueNode } from './valueNodes';
+
+export type InstructionByteDeltaNode = {
+  readonly kind: 'instructionByteDeltaNode';
+
+  // Children.
+  readonly value:
+    | NumberValueNode
+    | AccountLinkNode
+    | ArgumentValueNode
+    | ResolverValueNode;
+
+  // Data.
+  readonly withHeader: boolean;
+  readonly subtract?: boolean;
+};
+
+export function instructionByteDeltaNode(
+  value: InstructionByteDeltaNode['value'],
+  options: {
+    withHeader?: boolean;
+    subtract?: boolean;
+  } = {}
+): InstructionByteDeltaNode {
+  return {
+    kind: 'instructionByteDeltaNode',
+    value,
+    withHeader: options.withHeader ?? !isNode(value, 'resolverValueNode'),
+    subtract: options.subtract,
+  };
+}

src/nodes/InstructionNode.ts

@@ -1,10 +1,5 @@
 import type { IdlInstruction } from '../idl';
-import {
-  BytesCreatedOnChain,
-  InvalidKinobiTreeError,
-  MainCaseString,
-  mainCase,
-} from '../shared';
+import { InvalidKinobiTreeError, MainCaseString, mainCase } from '../shared';
 import {
   InstructionAccountNode,
   instructionAccountNodeFromIdl,
@@ -14,6 +9,7 @@ import {
   instructionArgumentNode,
   instructionArgumentNodeFromIdl,
 } from './InstructionArgumentNode';
+import { InstructionByteDeltaNode } from './InstructionByteDeltaNode';
 import { InstructionRemainingAccountsNode } from './InstructionRemainingAccountsNode';
 import { isNode } from './Node';
 import { ProgramNode } from './ProgramNode';
@@ -30,9 +26,7 @@ export type InstructionNode = {
   readonly extraArguments?: InstructionArgumentNode[];
   readonly subInstructions?: InstructionNode[];
   readonly remainingAccounts?: InstructionRemainingAccountsNode[];
-
-  // Children to-be.
-  readonly bytesCreatedOnChain?: BytesCreatedOnChain;
+  readonly byteDeltas?: InstructionByteDeltaNode[];
 
   // Data.
   readonly name: MainCaseString;
@@ -62,8 +56,8 @@ export function instructionNode(input: InstructionNodeInput): InstructionNode {
     subInstructions: input.subInstructions,
     idlName: input.idlName ?? input.name,
     docs: input.docs ?? [],
-    bytesCreatedOnChain: input.bytesCreatedOnChain,
     remainingAccounts: input.remainingAccounts,
+    byteDeltas: input.byteDeltas,
     optionalAccountStrategy: input.optionalAccountStrategy ?? 'programId',
   };
 }

src/nodes/Node.ts

@@ -4,6 +4,7 @@ import type { DefinedTypeNode } from './DefinedTypeNode';
 import type { ErrorNode } from './ErrorNode';
 import type { InstructionAccountNode } from './InstructionAccountNode';
 import type { InstructionArgumentNode } from './InstructionArgumentNode';
+import type { InstructionByteDeltaNode } from './InstructionByteDeltaNode';
 import type { InstructionNode } from './InstructionNode';
 import type { InstructionRemainingAccountsNode } from './InstructionRemainingAccountsNode';
 import type { PdaNode } from './PdaNode';
@@ -25,6 +26,7 @@ const REGISTERED_NODES = {
   accountNode: {} as AccountNode,
   instructionAccountNode: {} as InstructionAccountNode,
   instructionArgumentNode: {} as InstructionArgumentNode,
+  instructionByteDeltaNode: {} as InstructionByteDeltaNode,
   instructionNode: {} as InstructionNode,
   instructionRemainingAccountsNode: {} as InstructionRemainingAccountsNode,
   errorNode: {} as ErrorNode,

src/nodes/index.ts

@@ -3,6 +3,7 @@ export * from './DefinedTypeNode';
 export * from './ErrorNode';
 export * from './InstructionAccountNode';
 export * from './InstructionArgumentNode';
+export * from './InstructionByteDeltaNode';
 export * from './InstructionNode';
 export * from './InstructionRemainingAccountsNode';
 export * from './Node';

src/renderers/js-experimental/asyncHelpers.ts

@@ -10,9 +10,10 @@ export function hasAsyncFunction(
   resolvedInputs: ResolvedInstructionInput[],
   asyncResolvers: string[]
 ): boolean {
-  const hasBytesCreatedOnChainAsync =
-    instructionNode.bytesCreatedOnChain?.kind === 'resolver' &&
-    asyncResolvers.includes(instructionNode.bytesCreatedOnChain.name);
+  const hasByteDeltasAsync = (instructionNode.byteDeltas ?? []).some(
+    ({ value }) =>
+      isNode(value, 'resolverValueNode') && asyncResolvers.includes(value.name)
+  );
   const hasRemainingAccountsAsync = (
     instructionNode.remainingAccounts ?? []
   ).some(
@@ -22,7 +23,7 @@ export function hasAsyncFunction(
 
   return (
     hasAsyncDefaultValues(resolvedInputs, asyncResolvers) ||
-    hasBytesCreatedOnChainAsync ||
+    hasByteDeltasAsync ||
     hasRemainingAccountsAsync
   );
 }

src/renderers/js-experimental/fragments/index.ts

@@ -5,7 +5,7 @@ export * from './accountType';
 export * from './common';
 export * from './instructionAccountMeta';
 export * from './instructionAccountTypeParam';
-export * from './instructionBytesCreatedOnChain';
+export * from './instructionByteDelta';
 export * from './instructionData';
 export * from './instructionExtraArgs';
 export * from './instructionFunctionHighLevel';

src/renderers/js-experimental/fragments/instructionByteDelta.ts

@@ -0,0 +1,109 @@
+import {
+  InstructionByteDeltaNode,
+  InstructionNode,
+  assertIsNode,
+  isNode,
+} from '../../../nodes';
+import { camelCase } from '../../../shared';
+import type { GlobalFragmentScope } from '../getRenderMapVisitor';
+import { Fragment, fragment, mergeFragments } from './common';
+
+export function getInstructionByteDeltaFragment(
+  scope: Pick<GlobalFragmentScope, 'nameApi' | 'asyncResolvers'> & {
+    instructionNode: InstructionNode;
+    useAsync: boolean;
+  }
+): Fragment {
+  const { byteDeltas } = scope.instructionNode;
+  const fragments = (byteDeltas ?? []).flatMap((r) =>
+    getByteDeltaFragment(r, scope)
+  );
+  if (fragments.length === 0) return fragment('');
+  return mergeFragments(
+    fragments,
+    (r) =>
+      `// Bytes created or reallocated by the instruction.\n` +
+      `const byteDelta: number = [${r.join(',')}].reduce((a, b) => a + b, 0);`
+  );
+}
+
+function getByteDeltaFragment(
+  byteDelta: InstructionByteDeltaNode,
+  scope: Pick<GlobalFragmentScope, 'nameApi' | 'asyncResolvers'> & {
+    useAsync: boolean;
+  }
+): Fragment[] {
+  const bytesFragment = ((): Fragment | null => {
+    if (isNode(byteDelta.value, 'numberValueNode')) {
+      return getNumberValueNodeFragment(byteDelta);
+    }
+    if (isNode(byteDelta.value, 'argumentValueNode')) {
+      return getArgumentValueNodeFragment(byteDelta);
+    }
+    if (isNode(byteDelta.value, 'accountLinkNode')) {
+      return getAccountLinkNodeFragment(byteDelta, scope);
+    }
+    if (isNode(byteDelta.value, 'resolverValueNode')) {
+      return getResolverValueNodeFragment(byteDelta, scope);
+    }
+    return null;
+  })();
+
+  if (bytesFragment === null) return [];
+
+  if (byteDelta.withHeader) {
+    bytesFragment
+      .mapRender((r) => `${r} + BASE_ACCOUNT_SIZE`)
+      .addImports('solanaAccounts', 'BASE_ACCOUNT_SIZE');
+  }
+
+  if (byteDelta.subtract) {
+    bytesFragment.mapRender((r) => `- (${r})`);
+  }
+
+  return [bytesFragment];
+}
+
+function getNumberValueNodeFragment(
+  byteDelta: InstructionByteDeltaNode
+): Fragment {
+  assertIsNode(byteDelta.value, 'numberValueNode');
+  return fragment(byteDelta.value.number.toString());
+}
+
+function getArgumentValueNodeFragment(
+  byteDelta: InstructionByteDeltaNode
+): Fragment {
+  assertIsNode(byteDelta.value, 'argumentValueNode');
+  const argumentName = camelCase(byteDelta.value.name);
+  return fragment(`Number(args.${argumentName})`);
+}
+
+function getAccountLinkNodeFragment(
+  byteDelta: InstructionByteDeltaNode,
+  scope: Pick<GlobalFragmentScope, 'nameApi'>
+): Fragment {
+  assertIsNode(byteDelta.value, 'accountLinkNode');
+  const functionName = scope.nameApi.accountGetSizeFunction(
+    byteDelta.value.name
+  );
+  const importFrom = byteDelta.value.importFrom ?? 'generatedAccounts';
+  return fragment(`${functionName}()`).addImports(importFrom, functionName);
+}
+
+function getResolverValueNodeFragment(
+  byteDelta: InstructionByteDeltaNode,
+  scope: Pick<GlobalFragmentScope, 'nameApi' | 'asyncResolvers'> & {
+    useAsync: boolean;
+  }
+): Fragment | null {
+  assertIsNode(byteDelta.value, 'resolverValueNode');
+  const isAsync = scope.asyncResolvers.includes(byteDelta.value.name);
+  if (!scope.useAsync && isAsync) return null;
+
+  const awaitKeyword = scope.useAsync && isAsync ? 'await ' : '';
+  const functionName = scope.nameApi.resolverFunction(byteDelta.value.name);
+  return fragment(`${awaitKeyword}${functionName}(resolverScope)`)
+    .addImports(byteDelta.value.importFrom ?? 'hooked', functionName)
+    .addFeatures(['instruction:resolverScopeVariable']);
+}

src/renderers/js-experimental/fragments/instructionFunctionHighLevel.njk

@@ -52,8 +52,8 @@ export {{ 'async' if useAsync }} function {{ functionName }}<{{ typeParamsFragme
     {% endif %}
   );
 
-  {% if hasBytesCreatedOnChain %}
-    return Object.freeze({ ...instruction, bytesCreatedOnChain });
+  {% if hasByteDeltas %}
+    return Object.freeze({ ...instruction, byteDelta });
   {% else %}
     return instruction;
   {% endif %}

src/renderers/js-experimental/fragments/instructionFunctionHighLevel.ts

@@ -11,7 +11,7 @@ import {
   fragmentFromTemplate,
   mergeFragments,
 } from './common';
-import { getInstructionBytesCreatedOnChainFragment } from './instructionBytesCreatedOnChain';
+import { getInstructionByteDeltaFragment } from './instructionByteDelta';
 import { getInstructionInputResolvedFragment } from './instructionInputResolved';
 import { getInstructionInputTypeFragment } from './instructionInputType';
 import { getInstructionRemainingAccountsFragment } from './instructionRemainingAccounts';
@@ -111,25 +111,20 @@ export function getInstructionFunctionHighLevelFragment(
   const resolvedInputsFragment = getInstructionInputResolvedFragment(scope);
   const remainingAccountsFragment =
     getInstructionRemainingAccountsFragment(scope);
-  const bytesCreatedOnChainFragment =
-    getInstructionBytesCreatedOnChainFragment(scope);
+  const byteDeltaFragment = getInstructionByteDeltaFragment(scope);
   const resolvedFragment = mergeFragments(
-    [
-      resolvedInputsFragment,
-      remainingAccountsFragment,
-      bytesCreatedOnChainFragment,
-    ],
+    [resolvedInputsFragment, remainingAccountsFragment, byteDeltaFragment],
     (renders) => renders.join('\n\n')
   );
   const hasRemainingAccounts = remainingAccountsFragment.render !== '';
-  const hasBytesCreatedOnChain = bytesCreatedOnChainFragment.render !== '';
+  const hasByteDeltas = byteDeltaFragment.render !== '';
   const hasResolver = resolvedFragment.hasFeatures(
     'instruction:resolverScopeVariable'
   );
   const getReturnType = (instructionType: string) => {
     let returnType = instructionType;
-    if (hasBytesCreatedOnChain) {
-      returnType = `${returnType} & IInstructionWithBytesCreatedOnChain`;
+    if (hasByteDeltas) {
+      returnType = `${returnType} & IInstructionWithByteDelta`;
     }
     return useAsync ? `Promise<${returnType}>` : returnType;
   };
@@ -156,7 +151,7 @@ export function getInstructionFunctionHighLevelFragment(
       renamedArgs: renamedArgsText,
       resolvedFragment,
       hasRemainingAccounts,
-      hasBytesCreatedOnChain,
+      hasByteDeltas,
       hasResolver,
       useAsync,
       getReturnType,
@@ -181,10 +176,8 @@ export function getInstructionFunctionHighLevelFragment(
       .addImports('shared', ['getAccountMetasWithSigners', 'ResolvedAccount']);
   }
 
-  if (hasBytesCreatedOnChain) {
-    functionFragment.addImports('shared', [
-      'IInstructionWithBytesCreatedOnChain',
-    ]);
+  if (hasByteDeltas) {
+    functionFragment.addImports('shared', ['IInstructionWithByteDelta']);
   }
 
   return functionFragment;