Add node-types package (#2)

.eslintrc.js

@@ -1,5 +1,5 @@
 module.exports = {
     extends: ['turbo', '@solana/eslint-config-solana'],
     root: true,
-    ignorePatterns: ['.eslintrc.js', 'dist/'],
+    ignorePatterns: ['.eslintrc.js', '.eslintrc.cjs', 'dist/'],
 };

packages/library/package.json

@@ -53,6 +53,9 @@
         "test:treeshakability": "zx ../../node_modules/@kinobi-so/internals/scripts/test-treeshakability.mjs",
         "test:types": "zx ../../node_modules/@kinobi-so/internals/scripts/test-types.mjs"
     },
+    "dependencies": {
+        "@kinobi-so/nodes": "workspace:*"
+    },
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -64,8 +67,5 @@
     "browserslist": [
         "supports bigint and not dead",
         "maintained node versions"
-    ],
-    "dependencies": {
-        "@kinobi-so/nodes": "workspace:*"
-    }
+    ]
 }

packages/node-types/.eslintrc.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+    extends: ['../../.eslintrc.js'],
+    rules: {
+        'typescript-sort-keys/interface': 'off',
+    },
+};

packages/node-types/.gitignore

@@ -0,0 +1 @@
+dist/

packages/node-types/.prettierignore

@@ -0,0 +1 @@
+dist/

packages/node-types/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2024 Kinobi
+Copyright (c) 2024 Metaplex Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/node-types/README.md

@@ -0,0 +1,3 @@
+# Kinobi ➤ Node Types
+
+TODO

packages/node-types/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@kinobi-so/node-types",
+    "version": "0.20.0",
+    "description": "Node specifications for the Kinobi standard",
+    "exports": {
+        "types": "./dist/types/index.d.ts"
+    },
+    "types": "./dist/types/index.d.ts",
+    "files": [
+        "./dist/types"
+    ],
+    "sideEffects": false,
+    "keywords": [
+        "solana",
+        "framework",
+        "standard",
+        "specifications"
+    ],
+    "scripts": {
+        "build": "rimraf dist && pnpm build:types",
+        "build:types": "zx ../../node_modules/@kinobi-so/internals/scripts/build-types.mjs",
+        "lint": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs",
+        "lint:fix": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs --fix",
+        "prepublishOnly": "pnpm build",
+        "test": "pnpm test:types",
+        "test:types": "zx ../../node_modules/@kinobi-so/internals/scripts/test-types.mjs"
+    },
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/kinobi-so/kinobi"
+    },
+    "bugs": {
+        "url": "http://github.com/kinobi-so/kinobi/issues"
+    },
+    "browserslist": [
+        "supports bigint and not dead",
+        "maintained node versions"
+    ]
+}

packages/node-types/src/AccountNode.ts

@@ -0,0 +1,22 @@
+import type { DiscriminatorNode } from './discriminatorNodes';
+import type { PdaLinkNode } from './linkNodes';
+import type { MainCaseString } from './shared';
+import type { NestedTypeNode, StructTypeNode } from './typeNodes';
+
+export interface AccountNode<
+    TData extends NestedTypeNode<StructTypeNode> = NestedTypeNode<StructTypeNode>,
+    TPda extends PdaLinkNode | undefined = PdaLinkNode | undefined,
+    TDiscriminators extends DiscriminatorNode[] | undefined = DiscriminatorNode[] | undefined,
+> {
+    readonly kind: 'accountNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly size?: number | null;
+    readonly docs: string[];
+
+    // Children.
+    readonly data: TData;
+    readonly pda?: TPda;
+    readonly discriminators?: TDiscriminators;
+}

packages/node-types/src/DefinedTypeNode.ts

@@ -0,0 +1,13 @@
+import type { MainCaseString } from './shared';
+import type { TypeNode } from './typeNodes/TypeNode';
+
+export interface DefinedTypeNode<TType extends TypeNode = TypeNode> {
+    readonly kind: 'definedTypeNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly docs: string[];
+
+    // Children.
+    readonly type: TType;
+}

packages/node-types/src/ErrorNode.ts

@@ -0,0 +1,11 @@
+import type { MainCaseString } from './shared';
+
+export interface ErrorNode {
+    readonly kind: 'errorNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly code: number;
+    readonly message: string;
+    readonly docs: string[];
+}

packages/node-types/src/InstructionAccountNode.ts

@@ -0,0 +1,18 @@
+import type { InstructionInputValueNode } from './contextualValueNodes';
+import type { MainCaseString } from './shared';
+
+export interface InstructionAccountNode<
+    TDefaultValue extends InstructionInputValueNode | undefined = InstructionInputValueNode | undefined,
+> {
+    readonly kind: 'instructionAccountNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly isWritable: boolean;
+    readonly isSigner: boolean | 'either';
+    readonly isOptional: boolean;
+    readonly docs: string[];
+
+    // Children.
+    readonly defaultValue?: TDefaultValue;
+}

packages/node-types/src/InstructionArgumentNode.ts

@@ -0,0 +1,18 @@
+import type { InstructionInputValueNode } from './contextualValueNodes';
+import type { MainCaseString } from './shared';
+import type { TypeNode } from './typeNodes';
+
+export interface InstructionArgumentNode<
+    TDefaultValue extends InstructionInputValueNode | undefined = InstructionInputValueNode | undefined,
+> {
+    readonly kind: 'instructionArgumentNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly docs: string[];
+    readonly defaultValueStrategy?: 'omitted' | 'optional';
+
+    // Children.
+    readonly type: TypeNode;
+    readonly defaultValue?: TDefaultValue;
+}

packages/node-types/src/InstructionByteDeltaNode.ts

@@ -0,0 +1,18 @@
+import type { ArgumentValueNode, ResolverValueNode } from './contextualValueNodes';
+import type { AccountLinkNode } from './linkNodes';
+import type { NumberValueNode } from './valueNodes';
+
+type InstructionByteDeltaNodeValue = AccountLinkNode | ArgumentValueNode | NumberValueNode | ResolverValueNode;
+
+export interface InstructionByteDeltaNode<
+    TValue extends InstructionByteDeltaNodeValue = InstructionByteDeltaNodeValue,
+> {
+    readonly kind: 'instructionByteDeltaNode';
+
+    // Data.
+    readonly withHeader: boolean;
+    readonly subtract?: boolean;
+
+    // Children.
+    readonly value: TValue;
+}

packages/node-types/src/InstructionNode.ts

@@ -0,0 +1,36 @@
+import type { DiscriminatorNode } from './discriminatorNodes';
+import type { InstructionAccountNode } from './InstructionAccountNode';
+import type { InstructionArgumentNode } from './InstructionArgumentNode';
+import type { InstructionByteDeltaNode } from './InstructionByteDeltaNode';
+import type { InstructionRemainingAccountsNode } from './InstructionRemainingAccountsNode';
+import type { MainCaseString } from './shared';
+
+type SubInstructionNode = InstructionNode;
+
+export interface InstructionNode<
+    TAccounts extends InstructionAccountNode[] = InstructionAccountNode[],
+    TArguments extends InstructionArgumentNode[] = InstructionArgumentNode[],
+    TExtraArguments extends InstructionArgumentNode[] | undefined = InstructionArgumentNode[] | undefined,
+    TRemainingAccounts extends InstructionRemainingAccountsNode[] | undefined =
+        | InstructionRemainingAccountsNode[]
+        | undefined,
+    TByteDeltas extends InstructionByteDeltaNode[] | undefined = InstructionByteDeltaNode[] | undefined,
+    TDiscriminators extends DiscriminatorNode[] | undefined = DiscriminatorNode[] | undefined,
+    TSubInstructions extends SubInstructionNode[] | undefined = SubInstructionNode[] | undefined,
+> {
+    readonly kind: 'instructionNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly docs: string[];
+    readonly optionalAccountStrategy: 'omitted' | 'programId';
+
+    // Children.
+    readonly accounts: TAccounts;
+    readonly arguments: TArguments;
+    readonly extraArguments?: TExtraArguments;
+    readonly remainingAccounts?: TRemainingAccounts;
+    readonly byteDeltas?: TByteDeltas;
+    readonly discriminators?: TDiscriminators;
+    readonly subInstructions?: TSubInstructions;
+}

packages/node-types/src/InstructionRemainingAccountsNode.ts

@@ -0,0 +1,16 @@
+import type { ArgumentValueNode, ResolverValueNode } from './contextualValueNodes';
+
+export interface InstructionRemainingAccountsNode<
+    TValue extends ArgumentValueNode | ResolverValueNode = ArgumentValueNode | ResolverValueNode,
+> {
+    readonly kind: 'instructionRemainingAccountsNode';
+
+    // Data.
+    readonly docs: string[];
+    readonly isOptional?: boolean;
+    readonly isSigner?: boolean | 'either';
+    readonly isWritable?: boolean;
+
+    // Children.
+    readonly value: TValue;
+}

packages/node-types/src/Node.ts

@@ -0,0 +1,43 @@
+import type { AccountNode } from './AccountNode';
+import type { RegisteredContextualValueNode } from './contextualValueNodes/ContextualValueNode';
+import type { RegisteredCountNode } from './countNodes/CountNode';
+import type { DefinedTypeNode } from './DefinedTypeNode';
+import type { RegisteredDiscriminatorNode } from './discriminatorNodes/DiscriminatorNode';
+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 { RegisteredLinkNode } from './linkNodes/LinkNode';
+import type { PdaNode } from './PdaNode';
+import type { RegisteredPdaSeedNode } from './pdaSeedNodes/PdaSeedNode';
+import type { ProgramNode } from './ProgramNode';
+import type { RootNode } from './RootNode';
+import type { RegisteredTypeNode } from './typeNodes/TypeNode';
+import type { RegisteredValueNode } from './valueNodes/ValueNode';
+
+// Node Registration.
+export type NodeKind = Node['kind'];
+export type Node =
+    | AccountNode
+    | DefinedTypeNode
+    | ErrorNode
+    | InstructionAccountNode
+    | InstructionArgumentNode
+    | InstructionByteDeltaNode
+    | InstructionNode
+    | InstructionRemainingAccountsNode
+    | PdaNode
+    | ProgramNode
+    | RegisteredContextualValueNode
+    | RegisteredCountNode
+    | RegisteredDiscriminatorNode
+    | RegisteredLinkNode
+    | RegisteredPdaSeedNode
+    | RegisteredTypeNode
+    | RegisteredValueNode
+    | RootNode;
+
+// Node Helpers.
+export type GetNodeFromKind<TKind extends NodeKind> = Extract<Node, { kind: TKind }>;

packages/node-types/src/PdaNode.ts

@@ -0,0 +1,12 @@
+import type { PdaSeedNode } from './pdaSeedNodes';
+import type { MainCaseString } from './shared';
+
+export interface PdaNode<TSeeds extends PdaSeedNode[] = PdaSeedNode[]> {
+    readonly kind: 'pdaNode';
+
+    // Data.
+    readonly name: MainCaseString;
+
+    // Children.
+    readonly seeds: TSeeds;
+}

packages/node-types/src/ProgramNode.ts

@@ -0,0 +1,30 @@
+import type { AccountNode } from './AccountNode';
+import type { DefinedTypeNode } from './DefinedTypeNode';
+import type { ErrorNode } from './ErrorNode';
+import type { InstructionNode } from './InstructionNode';
+import type { PdaNode } from './PdaNode';
+import type { MainCaseString, ProgramVersion } from './shared';
+
+export interface ProgramNode<
+    TPdas extends PdaNode[] = PdaNode[],
+    TAccounts extends AccountNode[] = AccountNode[],
+    TInstructions extends InstructionNode[] = InstructionNode[],
+    TDefinedTypes extends DefinedTypeNode[] = DefinedTypeNode[],
+    TErrors extends ErrorNode[] = ErrorNode[],
+> {
+    readonly kind: 'programNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly prefix: MainCaseString;
+    readonly publicKey: string;
+    readonly version: ProgramVersion;
+    readonly origin?: 'anchor' | 'shank';
+
+    // Children.
+    readonly accounts: TAccounts;
+    readonly instructions: TInstructions;
+    readonly definedTypes: TDefinedTypes;
+    readonly pdas: TPdas;
+    readonly errors: TErrors;
+}

packages/node-types/src/RootNode.ts

@@ -0,0 +1,17 @@
+import type { ProgramNode } from './ProgramNode';
+import type { KinobiVersion } from './shared';
+
+export interface RootNode<
+    TProgram extends ProgramNode = ProgramNode,
+    TAdditionalPrograms extends ProgramNode[] = ProgramNode[],
+> {
+    readonly kind: 'rootNode';
+
+    // Data.
+    readonly standard: 'kinobi';
+    readonly version: KinobiVersion;
+
+    // Children.
+    readonly program: TProgram;
+    readonly additionalPrograms: TAdditionalPrograms;
+}

packages/node-types/src/contextualValueNodes/AccountBumpValueNode.ts

@@ -0,0 +1,8 @@
+import type { MainCaseString } from '../shared';
+
+export interface AccountBumpValueNode {
+    readonly kind: 'accountBumpValueNode';
+
+    // Data.
+    readonly name: MainCaseString;
+}

packages/node-types/src/contextualValueNodes/AccountValueNode.ts

@@ -0,0 +1,8 @@
+import type { MainCaseString } from '../shared';
+
+export interface AccountValueNode {
+    readonly kind: 'accountValueNode';
+
+    // Data.
+    readonly name: MainCaseString;
+}

packages/node-types/src/contextualValueNodes/ArgumentValueNode.ts

@@ -0,0 +1,8 @@
+import type { MainCaseString } from '../shared';
+
+export interface ArgumentValueNode {
+    readonly kind: 'argumentValueNode';
+
+    // Data.
+    readonly name: MainCaseString;
+}

packages/node-types/src/contextualValueNodes/ConditionalValueNode.ts

@@ -0,0 +1,23 @@
+import type { ValueNode } from '../valueNodes';
+import type { AccountValueNode } from './AccountValueNode';
+import type { ArgumentValueNode } from './ArgumentValueNode';
+import type { InstructionInputValueNode } from './ContextualValueNode';
+import type { ResolverValueNode } from './ResolverValueNode';
+
+type ConditionNode = AccountValueNode | ArgumentValueNode | ResolverValueNode;
+type ConditionStatementNode = InstructionInputValueNode;
+
+export interface ConditionalValueNode<
+    TCondition extends ConditionNode = ConditionNode,
+    TValue extends ValueNode | undefined = ValueNode | undefined,
+    TIfTrue extends ConditionStatementNode | undefined = ConditionStatementNode | undefined,
+    TIfFalse extends ConditionStatementNode | undefined = ConditionStatementNode | undefined,
+> {
+    readonly kind: 'conditionalValueNode';
+
+    // Children.
+    readonly condition: TCondition;
+    readonly value?: TValue;
+    readonly ifTrue?: TIfTrue;
+    readonly ifFalse?: TIfFalse;
+}

packages/node-types/src/contextualValueNodes/ContextualValueNode.ts

@@ -0,0 +1,31 @@
+import type { ProgramLinkNode } from '../linkNodes/ProgramLinkNode';
+import type { ValueNode } from '../valueNodes/ValueNode';
+import type { AccountBumpValueNode } from './AccountBumpValueNode';
+import type { AccountValueNode } from './AccountValueNode';
+import type { ArgumentValueNode } from './ArgumentValueNode';
+import type { ConditionalValueNode } from './ConditionalValueNode';
+import type { IdentityValueNode } from './IdentityValueNode';
+import type { PayerValueNode } from './PayerValueNode';
+import type { PdaSeedValueNode } from './PdaSeedValueNode';
+import type { PdaValueNode } from './PdaValueNode';
+import type { ProgramIdValueNode } from './ProgramIdValueNode';
+import type { ResolverValueNode } from './ResolverValueNode';
+
+// Standalone Contextual Value Node Registration.
+export type StandaloneContextualValueNode =
+    | AccountBumpValueNode
+    | AccountValueNode
+    | ArgumentValueNode
+    | ConditionalValueNode
+    | IdentityValueNode
+    | PayerValueNode
+    | PdaValueNode
+    | ProgramIdValueNode
+    | ResolverValueNode;
+
+// Contextual Value Node Registration.
+export type RegisteredContextualValueNode = PdaSeedValueNode | StandaloneContextualValueNode;
+
+// Contextual Value Node Helpers.
+export type ContextualValueNode = StandaloneContextualValueNode;
+export type InstructionInputValueNode = ContextualValueNode | ProgramLinkNode | ValueNode;

packages/node-types/src/contextualValueNodes/IdentityValueNode.ts

@@ -0,0 +1,3 @@
+export interface IdentityValueNode {
+    readonly kind: 'identityValueNode';
+}

packages/node-types/src/contextualValueNodes/PayerValueNode.ts

@@ -0,0 +1,3 @@
+export interface PayerValueNode {
+    readonly kind: 'payerValueNode';
+}

packages/node-types/src/contextualValueNodes/PdaSeedValueNode.ts

@@ -0,0 +1,16 @@
+import type { MainCaseString } from '../shared';
+import type { ValueNode } from '../valueNodes';
+import type { AccountValueNode } from './AccountValueNode';
+import type { ArgumentValueNode } from './ArgumentValueNode';
+
+export interface PdaSeedValueNode<
+    TValue extends AccountValueNode | ArgumentValueNode | ValueNode = AccountValueNode | ArgumentValueNode | ValueNode,
+> {
+    readonly kind: 'pdaSeedValueNode';
+
+    // Data.
+    readonly name: MainCaseString;
+
+    // Children.
+    readonly value: TValue;
+}

packages/node-types/src/contextualValueNodes/PdaValueNode.ts

@@ -0,0 +1,10 @@
+import type { PdaLinkNode } from '../linkNodes';
+import type { PdaSeedValueNode } from './PdaSeedValueNode';
+
+export interface PdaValueNode<TSeeds extends PdaSeedValueNode[] = PdaSeedValueNode[]> {
+    readonly kind: 'pdaValueNode';
+
+    // Children.
+    readonly pda: PdaLinkNode;
+    readonly seeds: TSeeds;
+}

packages/node-types/src/contextualValueNodes/ProgramIdValueNode.ts

@@ -0,0 +1,3 @@
+export interface ProgramIdValueNode {
+    readonly kind: 'programIdValueNode';
+}

packages/node-types/src/contextualValueNodes/ResolverValueNode.ts

@@ -0,0 +1,17 @@
+import type { ImportFrom, MainCaseString } from '../shared';
+import type { AccountValueNode } from './AccountValueNode';
+import type { ArgumentValueNode } from './ArgumentValueNode';
+
+export interface ResolverValueNode<
+    TDependsOn extends (AccountValueNode | ArgumentValueNode)[] = (AccountValueNode | ArgumentValueNode)[],
+> {
+    readonly kind: 'resolverValueNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly importFrom?: ImportFrom;
+    readonly docs: string[];
+
+    // Children.
+    readonly dependsOn?: TDependsOn;
+}

packages/node-types/src/contextualValueNodes/index.ts

@@ -0,0 +1,11 @@
+export * from './AccountBumpValueNode';
+export * from './AccountValueNode';
+export * from './ArgumentValueNode';
+export * from './ConditionalValueNode';
+export * from './ContextualValueNode';
+export * from './IdentityValueNode';
+export * from './PayerValueNode';
+export * from './PdaSeedValueNode';
+export * from './PdaValueNode';
+export * from './ProgramIdValueNode';
+export * from './ResolverValueNode';

packages/node-types/src/countNodes/CountNode.ts

@@ -0,0 +1,9 @@
+import type { FixedCountNode } from './FixedCountNode';
+import type { PrefixedCountNode } from './PrefixedCountNode';
+import type { RemainderCountNode } from './RemainderCountNode';
+
+// Count Node Registration.
+export type RegisteredCountNode = FixedCountNode | PrefixedCountNode | RemainderCountNode;
+
+// Count Node Helpers.
+export type CountNode = RegisteredCountNode;

packages/node-types/src/countNodes/FixedCountNode.ts

@@ -0,0 +1,6 @@
+export interface FixedCountNode {
+    readonly kind: 'fixedCountNode';
+
+    // Data.
+    readonly value: number;
+}

packages/node-types/src/countNodes/PrefixedCountNode.ts

@@ -0,0 +1,8 @@
+import type { NestedTypeNode, NumberTypeNode } from '../typeNodes';
+
+export interface PrefixedCountNode<TPrefix extends NestedTypeNode<NumberTypeNode> = NestedTypeNode<NumberTypeNode>> {
+    readonly kind: 'prefixedCountNode';
+
+    // Children.
+    readonly prefix: TPrefix;
+}

packages/node-types/src/countNodes/RemainderCountNode.ts

@@ -0,0 +1,3 @@
+export interface RemainderCountNode {
+    readonly kind: 'remainderCountNode';
+}

packages/node-types/src/countNodes/index.ts

@@ -0,0 +1,4 @@
+export * from './CountNode';
+export * from './FixedCountNode';
+export * from './PrefixedCountNode';
+export * from './RemainderCountNode';

packages/node-types/src/discriminatorNodes/ConstantDiscriminatorNode.ts

@@ -0,0 +1,11 @@
+import type { ConstantValueNode } from '../valueNodes';
+
+export interface ConstantDiscriminatorNode<TConstant extends ConstantValueNode = ConstantValueNode> {
+    readonly kind: 'constantDiscriminatorNode';
+
+    // Data.
+    readonly offset: number;
+
+    // Children.
+    readonly constant: TConstant;
+}

packages/node-types/src/discriminatorNodes/DiscriminatorNode.ts

@@ -0,0 +1,9 @@
+import type { ConstantDiscriminatorNode } from './ConstantDiscriminatorNode';
+import type { FieldDiscriminatorNode } from './FieldDiscriminatorNode';
+import type { SizeDiscriminatorNode } from './SizeDiscriminatorNode';
+
+// Discriminator Node Registration.
+export type RegisteredDiscriminatorNode = ConstantDiscriminatorNode | FieldDiscriminatorNode | SizeDiscriminatorNode;
+
+// Discriminator Node Helpers.
+export type DiscriminatorNode = RegisteredDiscriminatorNode;

packages/node-types/src/discriminatorNodes/FieldDiscriminatorNode.ts

@@ -0,0 +1,9 @@
+import type { MainCaseString } from '../shared';
+
+export interface FieldDiscriminatorNode {
+    readonly kind: 'fieldDiscriminatorNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly offset: number;
+}

packages/node-types/src/discriminatorNodes/SizeDiscriminatorNode.ts

@@ -0,0 +1,6 @@
+export interface SizeDiscriminatorNode {
+    readonly kind: 'sizeDiscriminatorNode';
+
+    // Data.
+    readonly size: number;
+}

packages/node-types/src/discriminatorNodes/index.ts

@@ -0,0 +1,4 @@
+export * from './ConstantDiscriminatorNode';
+export * from './DiscriminatorNode';
+export * from './FieldDiscriminatorNode';
+export * from './SizeDiscriminatorNode';

packages/node-types/src/index.ts

@@ -0,0 +1,21 @@
+export * from './AccountNode';
+export * from './DefinedTypeNode';
+export * from './ErrorNode';
+export * from './InstructionAccountNode';
+export * from './InstructionArgumentNode';
+export * from './InstructionByteDeltaNode';
+export * from './InstructionNode';
+export * from './InstructionRemainingAccountsNode';
+export * from './Node';
+export * from './PdaNode';
+export * from './ProgramNode';
+export * from './RootNode';
+
+export * from './contextualValueNodes';
+export * from './countNodes';
+export * from './discriminatorNodes';
+export * from './linkNodes';
+export * from './pdaSeedNodes';
+export * from './shared';
+export * from './typeNodes';
+export * from './valueNodes';

packages/node-types/src/linkNodes/AccountLinkNode.ts

@@ -0,0 +1,9 @@
+import type { ImportFrom, MainCaseString } from '../shared';
+
+export interface AccountLinkNode {
+    readonly kind: 'accountLinkNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly importFrom?: ImportFrom;
+}

packages/node-types/src/linkNodes/DefinedTypeLinkNode.ts

@@ -0,0 +1,9 @@
+import type { ImportFrom, MainCaseString } from '../shared';
+
+export interface DefinedTypeLinkNode {
+    readonly kind: 'definedTypeLinkNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly importFrom?: ImportFrom;
+}

packages/node-types/src/linkNodes/LinkNode.ts

@@ -0,0 +1,10 @@
+import type { AccountLinkNode } from './AccountLinkNode';
+import type { DefinedTypeLinkNode } from './DefinedTypeLinkNode';
+import type { PdaLinkNode } from './PdaLinkNode';
+import type { ProgramLinkNode } from './ProgramLinkNode';
+
+// Link Node Registration.
+export type RegisteredLinkNode = AccountLinkNode | DefinedTypeLinkNode | PdaLinkNode | ProgramLinkNode;
+
+// Link Node Helpers.
+export type LinkNode = RegisteredLinkNode;

packages/node-types/src/linkNodes/PdaLinkNode.ts

@@ -0,0 +1,9 @@
+import type { ImportFrom, MainCaseString } from '../shared';
+
+export interface PdaLinkNode {
+    readonly kind: 'pdaLinkNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly importFrom?: ImportFrom;
+}

packages/node-types/src/linkNodes/ProgramLinkNode.ts

@@ -0,0 +1,9 @@
+import type { ImportFrom, MainCaseString } from '../shared';
+
+export interface ProgramLinkNode {
+    readonly kind: 'programLinkNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly importFrom?: ImportFrom;
+}

packages/node-types/src/linkNodes/index.ts

@@ -0,0 +1,5 @@
+export * from './AccountLinkNode';
+export * from './DefinedTypeLinkNode';
+export * from './LinkNode';
+export * from './PdaLinkNode';
+export * from './ProgramLinkNode';

packages/node-types/src/pdaSeedNodes/ConstantPdaSeedNode.ts

@@ -0,0 +1,14 @@
+import type { ProgramIdValueNode } from '../contextualValueNodes';
+import type { TypeNode } from '../typeNodes';
+import type { ValueNode } from '../valueNodes';
+
+export interface ConstantPdaSeedNode<
+    TType extends TypeNode = TypeNode,
+    TValue extends ProgramIdValueNode | ValueNode = ProgramIdValueNode | ValueNode,
+> {
+    readonly kind: 'constantPdaSeedNode';
+
+    // Children.
+    readonly type: TType;
+    readonly value: TValue;
+}

packages/node-types/src/pdaSeedNodes/PdaSeedNode.ts

@@ -0,0 +1,8 @@
+import type { ConstantPdaSeedNode } from './ConstantPdaSeedNode';
+import type { VariablePdaSeedNode } from './VariablePdaSeedNode';
+
+// Pda Seed Node Registration.
+export type RegisteredPdaSeedNode = ConstantPdaSeedNode | VariablePdaSeedNode;
+
+// Pda Seed Node Helpers.
+export type PdaSeedNode = RegisteredPdaSeedNode;

packages/node-types/src/pdaSeedNodes/VariablePdaSeedNode.ts

@@ -0,0 +1,13 @@
+import type { MainCaseString } from '../shared';
+import type { TypeNode } from '../typeNodes';
+
+export interface VariablePdaSeedNode<TType extends TypeNode = TypeNode> {
+    readonly kind: 'variablePdaSeedNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly docs: string[];
+
+    // Children.
+    readonly type: TType;
+}

packages/node-types/src/pdaSeedNodes/index.ts

@@ -0,0 +1,3 @@
+export * from './ConstantPdaSeedNode';
+export * from './PdaSeedNode';
+export * from './VariablePdaSeedNode';

packages/node-types/src/shared/bytesEncoding.ts

@@ -0,0 +1 @@
+export type BytesEncoding = 'base16' | 'base58' | 'base64' | 'utf8';

packages/node-types/src/shared/importFrom.ts

@@ -0,0 +1,10 @@
+/**
+ * Tells Kinobi where a dependency is located.
+ *
+ * This could be a `hooked` dependency, or any other arbitrary dependency
+ * as long as renderers know how to map them into real libraries.
+ *
+ * `hooked` means the dependency is located in the source code but outside of the `generated` code.
+ * This is typically a dedicated folder that is used internally by the auto-generated code.
+ */
+export type ImportFrom = string | 'hooked';

packages/node-types/src/shared/index.ts

@@ -0,0 +1,4 @@
+export * from './bytesEncoding';
+export * from './importFrom';
+export * from './mainCase';
+export * from './version';

packages/node-types/src/shared/mainCase.ts

@@ -0,0 +1,3 @@
+export type MainCaseString = string & {
+    readonly __mainCaseString: unique symbol;
+};

packages/node-types/src/shared/version.ts

@@ -0,0 +1,4 @@
+type SemanticVersion = `${number}.${number}.${number}`;
+
+export type KinobiVersion = SemanticVersion;
+export type ProgramVersion = SemanticVersion;

packages/node-types/src/typeNodes/AmountTypeNode.ts

@@ -0,0 +1,13 @@
+import type { NestedTypeNode } from './NestedTypeNode';
+import type { NumberTypeNode } from './NumberTypeNode';
+
+export interface AmountTypeNode<TNumber extends NestedTypeNode<NumberTypeNode> = NestedTypeNode<NumberTypeNode>> {
+    readonly kind: 'amountTypeNode';
+
+    // Data.
+    readonly decimals: number;
+    readonly unit?: string;
+
+    // Children.
+    readonly number: TNumber;
+}

packages/node-types/src/typeNodes/ArrayTypeNode.ts

@@ -0,0 +1,10 @@
+import type { CountNode } from '../countNodes';
+import type { TypeNode } from './TypeNode';
+
+export interface ArrayTypeNode<TItem extends TypeNode = TypeNode, TCount extends CountNode = CountNode> {
+    readonly kind: 'arrayTypeNode';
+
+    // Children.
+    readonly item: TItem;
+    readonly count: TCount;
+}

packages/node-types/src/typeNodes/BooleanTypeNode.ts

@@ -0,0 +1,9 @@
+import type { NestedTypeNode } from './NestedTypeNode';
+import type { NumberTypeNode } from './NumberTypeNode';
+
+export interface BooleanTypeNode<TSize extends NestedTypeNode<NumberTypeNode> = NestedTypeNode<NumberTypeNode>> {
+    readonly kind: 'booleanTypeNode';
+
+    // Children.
+    readonly size: TSize;
+}

packages/node-types/src/typeNodes/BytesTypeNode.ts

@@ -0,0 +1,3 @@
+export interface BytesTypeNode {
+    readonly kind: 'bytesTypeNode';
+}

packages/node-types/src/typeNodes/DateTimeTypeNode.ts

@@ -0,0 +1,9 @@
+import type { NestedTypeNode } from './NestedTypeNode';
+import type { NumberTypeNode } from './NumberTypeNode';
+
+export interface DateTimeTypeNode<TNumber extends NestedTypeNode<NumberTypeNode> = NestedTypeNode<NumberTypeNode>> {
+    readonly kind: 'dateTimeTypeNode';
+
+    // Children.
+    readonly number: TNumber;
+}

packages/node-types/src/typeNodes/EnumEmptyVariantTypeNode.ts

@@ -0,0 +1,9 @@
+import type { MainCaseString } from '../shared';
+
+export interface EnumEmptyVariantTypeNode {
+    readonly kind: 'enumEmptyVariantTypeNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly discriminator?: number;
+}

packages/node-types/src/typeNodes/EnumStructVariantTypeNode.ts

@@ -0,0 +1,16 @@
+import type { MainCaseString } from '../shared';
+import type { NestedTypeNode } from './NestedTypeNode';
+import type { StructTypeNode } from './StructTypeNode';
+
+export interface EnumStructVariantTypeNode<
+    TStruct extends NestedTypeNode<StructTypeNode> = NestedTypeNode<StructTypeNode>,
+> {
+    readonly kind: 'enumStructVariantTypeNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly discriminator?: number;
+
+    // Children.
+    readonly struct: TStruct;
+}

packages/node-types/src/typeNodes/EnumTupleVariantTypeNode.ts

@@ -0,0 +1,16 @@
+import type { MainCaseString } from '../shared';
+import type { NestedTypeNode } from './NestedTypeNode';
+import type { TupleTypeNode } from './TupleTypeNode';
+
+export interface EnumTupleVariantTypeNode<
+    TTuple extends NestedTypeNode<TupleTypeNode> = NestedTypeNode<TupleTypeNode>,
+> {
+    readonly kind: 'enumTupleVariantTypeNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly discriminator?: number;
+
+    // Children.
+    readonly tuple: TTuple;
+}

packages/node-types/src/typeNodes/EnumTypeNode.ts

@@ -0,0 +1,14 @@
+import type { EnumVariantTypeNode } from './EnumVariantTypeNode';
+import type { NestedTypeNode } from './NestedTypeNode';
+import type { NumberTypeNode } from './NumberTypeNode';
+
+export interface EnumTypeNode<
+    TVariants extends EnumVariantTypeNode[] = EnumVariantTypeNode[],
+    TSize extends NestedTypeNode<NumberTypeNode> = NestedTypeNode<NumberTypeNode>,
+> {
+    readonly kind: 'enumTypeNode';
+
+    // Children.
+    readonly variants: TVariants;
+    readonly size: TSize;
+}

packages/node-types/src/typeNodes/EnumVariantTypeNode.ts

@@ -0,0 +1,5 @@
+import type { EnumEmptyVariantTypeNode } from './EnumEmptyVariantTypeNode';
+import type { EnumStructVariantTypeNode } from './EnumStructVariantTypeNode';
+import type { EnumTupleVariantTypeNode } from './EnumTupleVariantTypeNode';
+
+export type EnumVariantTypeNode = EnumEmptyVariantTypeNode | EnumStructVariantTypeNode | EnumTupleVariantTypeNode;

packages/node-types/src/typeNodes/FixedSizeTypeNode.ts

@@ -0,0 +1,11 @@
+import type { TypeNode } from './TypeNode';
+
+export interface FixedSizeTypeNode<TType extends TypeNode = TypeNode> {
+    readonly kind: 'fixedSizeTypeNode';
+
+    // Data.
+    readonly size: number;
+
+    // Children.
+    readonly type: TType;
+}

packages/node-types/src/typeNodes/HiddenPrefixTypeNode.ts

@@ -0,0 +1,13 @@
+import type { ConstantValueNode } from '../valueNodes';
+import type { TypeNode } from './TypeNode';
+
+export interface HiddenPrefixTypeNode<
+    TType extends TypeNode = TypeNode,
+    TPrefix extends ConstantValueNode[] = ConstantValueNode[],
+> {
+    readonly kind: 'hiddenPrefixTypeNode';
+
+    // Children.
+    readonly type: TType;
+    readonly prefix: TPrefix;
+}

packages/node-types/src/typeNodes/HiddenSuffixTypeNode.ts

@@ -0,0 +1,13 @@
+import type { ConstantValueNode } from '../valueNodes';
+import type { TypeNode } from './TypeNode';
+
+export interface HiddenSuffixTypeNode<
+    TType extends TypeNode = TypeNode,
+    TSuffix extends ConstantValueNode[] = ConstantValueNode[],
+> {
+    readonly kind: 'hiddenSuffixTypeNode';
+
+    // Children.
+    readonly type: TType;
+    readonly suffix: TSuffix;
+}

packages/node-types/src/typeNodes/MapTypeNode.ts

@@ -0,0 +1,15 @@
+import type { CountNode } from '../countNodes';
+import type { TypeNode } from './TypeNode';
+
+export interface MapTypeNode<
+    TKey extends TypeNode = TypeNode,
+    TValue extends TypeNode = TypeNode,
+    TCount extends CountNode = CountNode,
+> {
+    readonly kind: 'mapTypeNode';
+
+    // Children.
+    readonly key: TKey;
+    readonly value: TValue;
+    readonly count: TCount;
+}

packages/node-types/src/typeNodes/NestedTypeNode.ts

@@ -0,0 +1,18 @@
+import type { FixedSizeTypeNode } from './FixedSizeTypeNode';
+import type { HiddenPrefixTypeNode } from './HiddenPrefixTypeNode';
+import type { HiddenSuffixTypeNode } from './HiddenSuffixTypeNode';
+import type { PostOffsetTypeNode } from './PostOffsetTypeNode';
+import type { PreOffsetTypeNode } from './PreOffsetTypeNode';
+import type { SentinelTypeNode } from './SentinelTypeNode';
+import type { SizePrefixTypeNode } from './SizePrefixTypeNode';
+import type { TypeNode } from './TypeNode';
+
+export type NestedTypeNode<TType extends TypeNode> =
+    | FixedSizeTypeNode<NestedTypeNode<TType>>
+    | HiddenPrefixTypeNode<NestedTypeNode<TType>>
+    | HiddenSuffixTypeNode<NestedTypeNode<TType>>
+    | PostOffsetTypeNode<NestedTypeNode<TType>>
+    | PreOffsetTypeNode<NestedTypeNode<TType>>
+    | SentinelTypeNode<NestedTypeNode<TType>>
+    | SizePrefixTypeNode<NestedTypeNode<TType>>
+    | TType;

packages/node-types/src/typeNodes/NumberTypeNode.ts

@@ -0,0 +1,22 @@
+export type NumberFormat =
+    | 'f32'
+    | 'f64'
+    | 'i8'
+    | 'i16'
+    | 'i32'
+    | 'i64'
+    | 'i128'
+    | 'shortU16'
+    | 'u8'
+    | 'u16'
+    | 'u32'
+    | 'u64'
+    | 'u128';
+
+export interface NumberTypeNode<TFormat extends NumberFormat = NumberFormat> {
+    readonly kind: 'numberTypeNode';
+
+    // Data.
+    readonly format: TFormat;
+    readonly endian: 'be' | 'le';
+}

packages/node-types/src/typeNodes/OptionTypeNode.ts

@@ -0,0 +1,17 @@
+import type { NestedTypeNode } from './NestedTypeNode';
+import type { NumberTypeNode } from './NumberTypeNode';
+import type { TypeNode } from './TypeNode';
+
+export interface OptionTypeNode<
+    TItem extends TypeNode = TypeNode,
+    TPrefix extends NestedTypeNode<NumberTypeNode> = NestedTypeNode<NumberTypeNode>,
+> {
+    readonly kind: 'optionTypeNode';
+
+    // Data.
+    readonly fixed: boolean;
+
+    // Children.
+    readonly item: TItem;
+    readonly prefix: TPrefix;
+}

packages/node-types/src/typeNodes/PostOffsetTypeNode.ts

@@ -0,0 +1,12 @@
+import type { TypeNode } from './TypeNode';
+
+export interface PostOffsetTypeNode<TType extends TypeNode = TypeNode> {
+    readonly kind: 'postOffsetTypeNode';
+
+    // Data.
+    readonly offset: number;
+    readonly strategy: 'absolute' | 'padded' | 'preOffset' | 'relative';
+
+    // Children.
+    readonly type: TType;
+}

packages/node-types/src/typeNodes/PreOffsetTypeNode.ts

@@ -0,0 +1,12 @@
+import type { TypeNode } from './TypeNode';
+
+export interface PreOffsetTypeNode<TType extends TypeNode = TypeNode> {
+    readonly kind: 'preOffsetTypeNode';
+
+    // Data.
+    readonly offset: number;
+    readonly strategy: 'absolute' | 'padded' | 'relative';
+
+    // Children.
+    readonly type: TType;
+}

packages/node-types/src/typeNodes/PublicKeyTypeNode.ts

@@ -0,0 +1,3 @@
+export interface PublicKeyTypeNode {
+    readonly kind: 'publicKeyTypeNode';
+}

packages/node-types/src/typeNodes/SentinelTypeNode.ts

@@ -0,0 +1,13 @@
+import type { ConstantValueNode } from '../valueNodes';
+import type { TypeNode } from './TypeNode';
+
+export interface SentinelTypeNode<
+    TType extends TypeNode = TypeNode,
+    TSentinel extends ConstantValueNode = ConstantValueNode,
+> {
+    readonly kind: 'sentinelTypeNode';
+
+    // Children.
+    readonly type: TType;
+    readonly sentinel: TSentinel;
+}

packages/node-types/src/typeNodes/SetTypeNode.ts

@@ -0,0 +1,10 @@
+import type { CountNode } from '../countNodes';
+import type { TypeNode } from './TypeNode';
+
+export interface SetTypeNode<TItem extends TypeNode = TypeNode, TCount extends CountNode = CountNode> {
+    readonly kind: 'setTypeNode';
+
+    // Children.
+    readonly item: TItem;
+    readonly count: TCount;
+}

packages/node-types/src/typeNodes/SizePrefixTypeNode.ts

@@ -0,0 +1,14 @@
+import type { NestedTypeNode } from './NestedTypeNode';
+import type { NumberTypeNode } from './NumberTypeNode';
+import type { TypeNode } from './TypeNode';
+
+export interface SizePrefixTypeNode<
+    TType extends TypeNode = TypeNode,
+    TPrefix extends NestedTypeNode<NumberTypeNode> = NestedTypeNode<NumberTypeNode>,
+> {
+    readonly kind: 'sizePrefixTypeNode';
+
+    // Children.
+    readonly type: TType;
+    readonly prefix: TPrefix;
+}

packages/node-types/src/typeNodes/SolAmountTypeNode.ts

@@ -0,0 +1,9 @@
+import type { NestedTypeNode } from './NestedTypeNode';
+import type { NumberTypeNode } from './NumberTypeNode';
+
+export interface SolAmountTypeNode<TNumber extends NestedTypeNode<NumberTypeNode> = NestedTypeNode<NumberTypeNode>> {
+    readonly kind: 'solAmountTypeNode';
+
+    // Children.
+    readonly number: TNumber;
+}

packages/node-types/src/typeNodes/StringTypeNode.ts

@@ -0,0 +1,8 @@
+import type { BytesEncoding } from '../shared';
+
+export interface StringTypeNode<TEncoding extends BytesEncoding = BytesEncoding> {
+    readonly kind: 'stringTypeNode';
+
+    // Data.
+    readonly encoding: TEncoding;
+}

packages/node-types/src/typeNodes/StructFieldTypeNode.ts

@@ -0,0 +1,19 @@
+import type { MainCaseString } from '../shared';
+import type { ValueNode } from '../valueNodes';
+import type { TypeNode } from './TypeNode';
+
+export interface StructFieldTypeNode<
+    TType extends TypeNode = TypeNode,
+    TDefaultValue extends ValueNode | undefined = ValueNode | undefined,
+> {
+    readonly kind: 'structFieldTypeNode';
+
+    // Data.
+    readonly name: MainCaseString;
+    readonly defaultValueStrategy?: 'omitted' | 'optional';
+    readonly docs: string[];
+
+    // Children.
+    readonly type: TType;
+    readonly defaultValue?: TDefaultValue;
+}

packages/node-types/src/typeNodes/StructTypeNode.ts

@@ -0,0 +1,8 @@
+import type { StructFieldTypeNode } from './StructFieldTypeNode';
+
+export interface StructTypeNode<TFields extends StructFieldTypeNode[] = StructFieldTypeNode[]> {
+    readonly kind: 'structTypeNode';
+
+    // Children.
+    readonly fields: TFields;
+}

packages/node-types/src/typeNodes/TupleTypeNode.ts

@@ -0,0 +1,8 @@
+import type { TypeNode } from './TypeNode';
+
+export interface TupleTypeNode<TItems extends TypeNode[] = TypeNode[]> {
+    readonly kind: 'tupleTypeNode';
+
+    // Children.
+    readonly items: TItems;
+}

packages/node-types/src/typeNodes/TypeNode.ts

@@ -0,0 +1,70 @@
+import type { DefinedTypeLinkNode } from '../linkNodes/DefinedTypeLinkNode';
+import type { AmountTypeNode } from './AmountTypeNode';
+import type { ArrayTypeNode } from './ArrayTypeNode';
+import type { BooleanTypeNode } from './BooleanTypeNode';
+import type { BytesTypeNode } from './BytesTypeNode';
+import type { DateTimeTypeNode } from './DateTimeTypeNode';
+import type { EnumEmptyVariantTypeNode } from './EnumEmptyVariantTypeNode';
+import type { EnumStructVariantTypeNode } from './EnumStructVariantTypeNode';
+import type { EnumTupleVariantTypeNode } from './EnumTupleVariantTypeNode';
+import type { EnumTypeNode } from './EnumTypeNode';
+import type { FixedSizeTypeNode } from './FixedSizeTypeNode';
+import type { HiddenPrefixTypeNode } from './HiddenPrefixTypeNode';
+import type { HiddenSuffixTypeNode } from './HiddenSuffixTypeNode';
+import type { MapTypeNode } from './MapTypeNode';
+import type { NumberTypeNode } from './NumberTypeNode';
+import type { OptionTypeNode } from './OptionTypeNode';
+import type { PostOffsetTypeNode } from './PostOffsetTypeNode';
+import type { PreOffsetTypeNode } from './PreOffsetTypeNode';
+import type { PublicKeyTypeNode } from './PublicKeyTypeNode';
+import type { SentinelTypeNode } from './SentinelTypeNode';
+import type { SetTypeNode } from './SetTypeNode';
+import type { SizePrefixTypeNode } from './SizePrefixTypeNode';
+import type { SolAmountTypeNode } from './SolAmountTypeNode';
+import type { StringTypeNode } from './StringTypeNode';
+import type { StructFieldTypeNode } from './StructFieldTypeNode';
+import type { StructTypeNode } from './StructTypeNode';
+import type { TupleTypeNode } from './TupleTypeNode';
+import type { ZeroableOptionTypeNode } from './ZeroableOptionTypeNode';
+
+// Standalone Type Node Registration.
+export type StandaloneTypeNode =
+    | AmountTypeNode
+    | ArrayTypeNode
+    | BooleanTypeNode
+    | BytesTypeNode
+    | DateTimeTypeNode
+    | EnumTypeNode
+    | FixedSizeTypeNode
+    | HiddenPrefixTypeNode
+    | HiddenSuffixTypeNode
+    | MapTypeNode
+    | NumberTypeNode
+    | OptionTypeNode
+    | PostOffsetTypeNode
+    | PreOffsetTypeNode
+    | PublicKeyTypeNode
+    | SentinelTypeNode
+    | SetTypeNode
+    | SizePrefixTypeNode
+    | SolAmountTypeNode
+    | StringTypeNode
+    | StructTypeNode
+    | TupleTypeNode
+    | ZeroableOptionTypeNode;
+
+// Type Node Registration.
+export type RegisteredTypeNode =
+    | EnumEmptyVariantTypeNode
+    | EnumStructVariantTypeNode
+    | EnumTupleVariantTypeNode
+    | StandaloneTypeNode
+    | StructFieldTypeNode;
+
+/**
+ * Type Node Helper.
+ * This only includes type nodes that can be used as standalone types.
+ * E.g. this excludes structFieldTypeNode, enumEmptyVariantTypeNode, etc.
+ * It also includes the definedTypeLinkNode to compose types.
+ */
+export type TypeNode = DefinedTypeLinkNode | StandaloneTypeNode;

packages/node-types/src/typeNodes/ZeroableOptionTypeNode.ts

@@ -0,0 +1,13 @@
+import type { ConstantValueNode } from '../valueNodes';
+import type { TypeNode } from './TypeNode';
+
+export interface ZeroableOptionTypeNode<
+    TItem extends TypeNode = TypeNode,
+    TZeroValue extends ConstantValueNode | undefined = ConstantValueNode | undefined,
+> {
+    readonly kind: 'zeroableOptionTypeNode';
+
+    // Children.
+    readonly item: TItem;
+    readonly zeroValue?: TZeroValue;
+}

packages/node-types/src/typeNodes/index.ts

@@ -0,0 +1,30 @@
+export * from './AmountTypeNode';
+export * from './ArrayTypeNode';
+export * from './BooleanTypeNode';
+export * from './BytesTypeNode';
+export * from './DateTimeTypeNode';
+export * from './EnumEmptyVariantTypeNode';
+export * from './EnumStructVariantTypeNode';
+export * from './EnumTupleVariantTypeNode';
+export * from './EnumTypeNode';
+export * from './EnumVariantTypeNode';
+export * from './FixedSizeTypeNode';
+export * from './HiddenPrefixTypeNode';
+export * from './HiddenSuffixTypeNode';
+export * from './MapTypeNode';
+export * from './NestedTypeNode';
+export * from './NumberTypeNode';
+export * from './OptionTypeNode';
+export * from './PostOffsetTypeNode';
+export * from './PreOffsetTypeNode';
+export * from './PublicKeyTypeNode';
+export * from './SentinelTypeNode';
+export * from './SetTypeNode';
+export * from './SizePrefixTypeNode';
+export * from './SolAmountTypeNode';
+export * from './StringTypeNode';
+export * from './StructFieldTypeNode';
+export * from './StructTypeNode';
+export * from './TupleTypeNode';
+export * from './TypeNode';
+export * from './ZeroableOptionTypeNode';

packages/node-types/src/valueNodes/ArrayValueNode.ts

@@ -0,0 +1,8 @@
+import type { ValueNode } from './ValueNode';
+
+export interface ArrayValueNode<TItems extends ValueNode[] = ValueNode[]> {
+    readonly kind: 'arrayValueNode';
+
+    // Children.
+    readonly items: TItems;
+}

packages/node-types/src/valueNodes/BooleanValueNode.ts

@@ -0,0 +1,6 @@
+export interface BooleanValueNode {
+    readonly kind: 'booleanValueNode';
+
+    // Data.
+    readonly boolean: boolean;
+}

packages/node-types/src/valueNodes/BytesValueNode.ts

@@ -0,0 +1,9 @@
+import type { BytesEncoding } from '../shared';
+
+export interface BytesValueNode {
+    readonly kind: 'bytesValueNode';
+
+    // Data.
+    readonly data: string;
+    readonly encoding: BytesEncoding;
+}

packages/node-types/src/valueNodes/ConstantValueNode.ts

@@ -0,0 +1,10 @@
+import type { TypeNode } from '../typeNodes/TypeNode';
+import type { ValueNode } from './ValueNode';
+
+export interface ConstantValueNode<TType extends TypeNode = TypeNode, TValue extends ValueNode = ValueNode> {
+    readonly kind: 'constantValueNode';
+
+    // Children.
+    readonly type: TType;
+    readonly value: TValue;
+}

packages/node-types/src/valueNodes/EnumValueNode.ts

@@ -0,0 +1,18 @@
+import type { DefinedTypeLinkNode } from '../linkNodes';
+import type { MainCaseString } from '../shared';
+import type { StructValueNode } from './StructValueNode';
+import type { TupleValueNode } from './TupleValueNode';
+
+export interface EnumValueNode<
+    TEnum extends DefinedTypeLinkNode = DefinedTypeLinkNode,
+    TValue extends StructValueNode | TupleValueNode | undefined = StructValueNode | TupleValueNode | undefined,
+> {
+    readonly kind: 'enumValueNode';
+
+    // Data.
+    readonly variant: MainCaseString;
+
+    // Children.
+    readonly enum: TEnum;
+    readonly value?: TValue;
+}

packages/node-types/src/valueNodes/MapEntryValueNode.ts

@@ -0,0 +1,9 @@
+import type { ValueNode } from './ValueNode';
+
+export interface MapEntryValueNode<TKey extends ValueNode = ValueNode, TValue extends ValueNode = ValueNode> {
+    readonly kind: 'mapEntryValueNode';
+
+    // Children.
+    readonly key: TKey;
+    readonly value: TValue;
+}

packages/node-types/src/valueNodes/MapValueNode.ts

@@ -0,0 +1,8 @@
+import type { MapEntryValueNode } from './MapEntryValueNode';
+
+export interface MapValueNode<TEntries extends MapEntryValueNode[] = MapEntryValueNode[]> {
+    readonly kind: 'mapValueNode';
+
+    // Children.
+    readonly entries: TEntries;
+}

packages/node-types/src/valueNodes/NoneValueNode.ts

@@ -0,0 +1,3 @@
+export interface NoneValueNode {
+    readonly kind: 'noneValueNode';
+}

packages/node-types/src/valueNodes/NumberValueNode.ts

@@ -0,0 +1,6 @@
+export interface NumberValueNode {
+    readonly kind: 'numberValueNode';
+
+    // Data.
+    readonly number: number;
+}

packages/node-types/src/valueNodes/PublicKeyValueNode.ts

@@ -0,0 +1,9 @@
+import type { MainCaseString } from '../shared';
+
+export interface PublicKeyValueNode {
+    readonly kind: 'publicKeyValueNode';
+
+    // Data.
+    readonly publicKey: string;
+    readonly identifier?: MainCaseString;
+}

packages/node-types/src/valueNodes/SetValueNode.ts

@@ -0,0 +1,8 @@
+import type { ValueNode } from './ValueNode';
+
+export interface SetValueNode<TItems extends ValueNode[] = ValueNode[]> {
+    readonly kind: 'setValueNode';
+
+    // Children.
+    readonly items: TItems;
+}