Create zod schemas for StackItem

src/parser/index.ts

@@ -1,12 +1,12 @@
 import { TupleItem, TupleReader } from '@ton/core';
-import type { StackItem } from './types';
+import { stackItemSchema } from './types';
 import { parseStackItem } from './parseStackItem';
 
 export function parseStack(src: unknown[]) {
   let stack: TupleItem[] = [];
 
   for (let s of src) {
-      stack.push(parseStackItem(s as StackItem));
+      stack.push(parseStackItem(stackItemSchema.parse(s)));
   }
 
   return new TupleReader(stack);

src/parser/types/stackItems.ts

@@ -1,16 +1,42 @@
+import { z } from 'zod';
 import type { TvmTuple, TvmList } from './tvmValues';
 
-type SerializedCell = { bytes: string };
+const serializedCellSchema = z.object({
+  bytes: z.string(),
+});
+type SerializedCell = z.infer<typeof serializedCellSchema>;
 
-type NullStackItem = ['null'];
-type NumStackItem = ['num', string];
-type CellStackItem = ['cell', SerializedCell];
-type SliceStackItem = ['slice', SerializedCell];
-type BuilderStackItem = ['builder', SerializedCell];
+const nullSchema = z.union([
+  z.tuple([z.literal('null')]),
+  z.tuple([z.literal('null'), z.null().optional()]),
+]);
+type NullStackItem = z.infer<typeof nullSchema>;
 
-type TupleStackItem = ['tuple', TvmTuple];
-type ListStackItem = ['list', TvmList];
+const numSchema = z.tuple([z.literal('num'), z.string()]);
+type NumStackItem = z.infer<typeof numSchema>;
 
-export type StackItem = NullStackItem | NumStackItem 
-  | CellStackItem | SliceStackItem | BuilderStackItem
-  | TupleStackItem | ListStackItem;
+const cellSchema = z.tuple([z.literal('cell'), serializedCellSchema]);
+type CellStackItem = z.infer<typeof cellSchema>;
+
+const sliceSchema = z.tuple([z.literal('slice'), serializedCellSchema]);
+type SliceStackItem = z.infer<typeof sliceSchema>;
+
+const builderSchema = z.tuple([z.literal('builder'), serializedCellSchema]);
+type BuilderStackItem = z.infer<typeof builderSchema>;
+
+const tupleSchema = z.tuple([z.literal('tuple'), z.unknown() as z.ZodType<TvmTuple>]);
+type TupleStackItem = z.infer<typeof tupleSchema>;
+
+const listSchema = z.tuple([z.literal('list'), z.unknown() as z.ZodType<TvmList>]);
+type ListStackItem = z.infer<typeof listSchema>;
+
+export const stackItemSchema = z.union([
+  nullSchema,
+  numSchema,
+  cellSchema,
+  sliceSchema,
+  builderSchema,
+  tupleSchema,
+  listSchema,
+]);
+export type StackItem = NullStackItem | NumStackItem | CellStackItem | SliceStackItem | BuilderStackItem | TupleStackItem | ListStackItem;

src/parser/types/tvmValues.ts

@@ -9,6 +9,7 @@ type TvmCell = { '@type': 'tvm.cell', bytes: string };
 type TvmStackEntryCell = { '@type': 'tvm.stackEntryCell', cell: TvmCell };
 
 // Structured types for TON Virtual Machine values
+// TODO: Check how list parsing works
 export type TvmList = { '@type': 'tvm.list', elements: TvmValue[] };
 type TvmStackEntryList = { '@type': 'tvm.stackEntryList', list: TvmList };