gen-typescript-from-tolk-dev 0.2.4 → 0.3.0

package/dist/emit-stack-rw.js

@@ -11,7 +11,8 @@ const types_kernel_1 = require("./types-kernel");
 // Emit a TS "read {ty} from a stack `r`" expression.
 // Parameter `fieldPath` is used for error messages only.
 // Used to read getters return value, since contract getters work via the stack, not serialization.
-function emitStackReadExpr(ctx, fieldPath, ty, unTupleIfW = false) {
+function emitStackReadExpr(ctx, fieldPath, tyIdx, unTupleIfW = false, uLabelTyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     ctx.stackReadsUnknown || (ctx.stackReadsUnknown = ty.kind === 'unknown');
     ctx.stackReadsArrayOf || (ctx.stackReadsArrayOf = ty.kind === 'arrayOf');
     ctx.stackReadsLispListOf || (ctx.stackReadsLispListOf = ty.kind === 'lispListOf');
@@ -19,15 +20,15 @@ function emitStackReadExpr(ctx, fieldPath, ty, unTupleIfW = false) {
     ctx.stackReadsTuple || (ctx.stackReadsTuple = ty.kind === 'arrayOf' || ty.kind === 'lispListOf' || ty.kind === 'shapedTuple');
     ctx.stackReadsMapKV || (ctx.stackReadsMapKV = ty.kind === 'mapKV');
     ctx.stackReadsBuilder || (ctx.stackReadsBuilder = ty.kind === 'builder');
-    ctx.stackReadsNullable || (ctx.stackReadsNullable = ty.kind === 'nullable');
+    ctx.stackReadsNullable || (ctx.stackReadsNullable = ty.kind === 'nullable' || ty.kind === 'addressOpt');
     ctx.stackReadsWideNullable || (ctx.stackReadsWideNullable = ty.kind === 'nullable' && ty.stack_type_id !== undefined);
     ctx.stackReadsUnionType || (ctx.stackReadsUnionType = ty.kind === 'union');
     ctx.stackReadsCellRef || (ctx.stackReadsCellRef = ty.kind === 'cellOf');
     ctx.stackReadsNullLiteral || (ctx.stackReadsNullLiteral = ty.kind === 'nullLiteral');
     if (unTupleIfW) { // inside `array<T>` or `[T, ...]`, if T is non-primitive, it's a sub-tuple
-        let wOnStack = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, ty);
+        let wOnStack = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, tyIdx);
         if (wOnStack !== 1) {
-            return `r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, ty)}>(${wOnStack}, ${emitStackReadCallback(ctx, fieldPath, ty, false)})`;
+            return `r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, tyIdx)}>(${wOnStack}, ${emitStackReadCallback(ctx, fieldPath, tyIdx, false, uLabelTyIdx)})`;
         }
     }
     switch (ty.kind) {
@@ -44,67 +45,68 @@ function emitStackReadExpr(ctx, fieldPath, ty, unTupleIfW = false) {
         case 'string': return `r.readSnakeString()`;
         case 'remaining': return `r.readSlice()`;
         case 'address': return `r.readSlice().loadAddress()`;
-        case 'addressOpt': return emitStackReadExpr(ctx, fieldPath, { kind: 'nullable', inner: { kind: 'address' } });
+        case 'addressOpt': return `r.readNullable<c.Address>((r) => r.readSlice().loadAddress())`;
         case 'addressExt': return `r.readSlice().loadExternalAddress()`;
         case 'addressAny': return `${codegen_ctx_1.RUNTIME.loadTolkAddressAny}(r.readSlice())`;
         case 'bitsN': return `r.readSlice()`;
         case 'nullLiteral': return `r.readNullLiteral()`;
-        case 'callable': throw new unsupported_errors_1.NotSupportedTypeOnStack(ty, fieldPath);
+        case 'callable': throw new unsupported_errors_1.NotSupportedTypeOnStack((0, types_kernel_1.renderTy)(ctx.symbols, tyIdx), fieldPath);
         case 'void': return `void 0`;
         case 'unknown': return `r.readUnknown()`;
         case 'nullable': {
             if (ty.stack_type_id) {
-                return `r.readWideNullable<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${ty.stack_width}, ${emitStackReadCallback(ctx, fieldPath, ty.inner, false)})`;
+                return `r.readWideNullable<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${ty.stack_width}, ${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, false)})`;
             }
-            return `r.readNullable<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner, false)})`;
+            return `r.readNullable<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, false)})`;
         }
-        case 'cellOf': return `r.readCellRef<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${(0, emit_pack_unpack_1.emitLoadCallback)(ctx, fieldPath + '.ref', ty.inner)})`;
-        case 'arrayOf': return `r.readArrayOf<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner, true)})`;
-        case 'lispListOf': return `r.readLispListOf<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner, true)})`;
+        case 'cellOf': return `r.readCellRef<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${(0, emit_pack_unpack_1.emitLoadCallback)(ctx, fieldPath + '.ref', ty.inner_ty_idx)})`;
+        case 'arrayOf': return `r.readArrayOf<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, true)})`;
+        case 'lispListOf': return `r.readLispListOf<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, true)})`;
         case 'tensor': {
             let buf = new formatting_1.OutBuf();
             buf.push(`[`);
-            for (let i = 0; i < ty.items.length; ++i) {
-                buf.push(emitStackReadExpr(ctx, `${fieldPath}[${i}]`, ty.items[i]) + ',');
+            for (let i = 0; i < ty.items_ty_idx.length; ++i) {
+                buf.push(emitStackReadExpr(ctx, `${fieldPath}[${i}]`, ty.items_ty_idx[i]) + ',');
             }
             buf.push(']');
             return buf.toString();
         }
         case 'shapedTuple': {
             let buf = new formatting_1.OutBuf();
-            buf.push(`r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, ty)}>(${ty.items.length}, (r) => [`);
-            for (let i = 0; i < ty.items.length; ++i) {
-                buf.push(emitStackReadExpr(ctx, `${fieldPath}[${i}]`, ty.items[i], true) + ',');
+            buf.push(`r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, tyIdx)}>(${ty.items_ty_idx.length}, (r) => [`);
+            for (let i = 0; i < ty.items_ty_idx.length; ++i) {
+                buf.push(emitStackReadExpr(ctx, `${fieldPath}[${i}]`, ty.items_ty_idx[i], true) + ',');
             }
             buf.push('])');
             return buf.toString();
         }
-        case 'mapKV': return `r.readDictionary<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.k, ty.v)}>(${(0, emit_pack_unpack_1.emitDictKVSerializers)(ctx, fieldPath, ty.k, ty.v)})`;
+        case 'mapKV': return `r.readDictionary<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.key_ty_idx, ty.value_ty_idx)}>(${(0, emit_pack_unpack_1.emitDictKVSerializers)(ctx, fieldPath, ty.key_ty_idx, ty.value_ty_idx)})`;
         case 'EnumRef': return `r.readBigInt()`;
         case 'StructRef': {
-            const structRef = ctx.symbols.getStruct(ty.struct_name);
             let buf = new formatting_1.OutBuf();
             buf.push(`({`);
             buf.push(`$: '${ty.struct_name}',`);
-            for (let f of structRef.fields) {
-                const fTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(f.ty, structRef.type_params, ty.type_args) : f.ty;
-                buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${emitStackReadExpr(ctx, `${fieldPath}.${f.name}`, fTy)},`);
+            for (let f of ctx.symbols.structFieldsOf(tyIdx)) {
+                buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${emitStackReadExpr(ctx, `${fieldPath}.${f.name}`, f.ty_idx, false, f.uLabelTyIdx)},`);
             }
             buf.push(`})`);
             return buf.toString();
         }
         case 'AliasRef': {
-            const aliasRef = ctx.symbols.getAlias(ty.alias_name);
-            const targetTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(aliasRef.target_ty, aliasRef.type_params, ty.type_args) : aliasRef.target_ty;
-            return emitStackReadExpr(ctx, fieldPath, targetTy);
+            const target = ctx.symbols.aliasTargetOf(tyIdx);
+            return emitStackReadExpr(ctx, fieldPath, target.ty_idx, unTupleIfW, target.uLabelTyIdx);
         }
-        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} in '${fieldPath}'`);
+        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} at '${fieldPath}'`);
         case 'union': {
-            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
+            if (ty.stack_width === undefined) {
+                throw new Error(`unexpected stack_width=undefined at ${fieldPath}`);
+            }
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants, uLabelTyIdx);
             let buf = new formatting_1.OutBuf();
-            buf.push(`r.readUnionType<${(0, emit_ts_types_1.emitTsType)(ctx, ty)}>(${ty.stack_width}, {`);
+            let tsUniTypeStr = variants.map(v => (0, emit_ts_types_1.emitUnionLabelAndValue)(v, (0, emit_ts_types_1.emitTsType)(ctx, v.variant_ty_idx))).join(' | ');
+            buf.push(`r.readUnionType<${tsUniTypeStr}>(${ty.stack_width}, {`);
             for (let v of variants) {
-                buf.push(`${v.stack_type_id}: [${v.stack_width}, ${v.hasValueField ? `'${v.labelStr}'` : 'null'}, ${emitStackReadCallback(ctx, `${fieldPath}#${v.stack_type_id}`, v.variant_ty, false)}],`);
+                buf.push(`${v.stack_type_id}: [${v.stack_width}, ${v.hasValueField ? `'${v.labelStr}'` : 'null'}, ${emitStackReadCallback(ctx, `${fieldPath}#${v.stack_type_id}`, v.variant_ty_idx, false, uLabelTyIdx)}],`);
             }
             buf.push(`})`);
             return buf.toString();
@@ -113,20 +115,21 @@ function emitStackReadExpr(ctx, fieldPath, ty, unTupleIfW = false) {
 }
 // Emit a TS "read {ty} from a stack `r`" callback (not expression).
 // Callbacks are passed for generics — for example, to read a nullable (when a stack slot is not null).
-function emitStackReadCallback(ctx, fieldPath, ty, unTupleIfW) {
-    return formatting_1.OutBuf.onNewLine(`(r) => ${emitStackReadExpr(ctx, fieldPath, ty, unTupleIfW)}`);
+function emitStackReadCallback(ctx, fieldPath, tyIdx, unTupleIfW, uLabelTyIdx) {
+    return formatting_1.OutBuf.onNewLine(`(r) => ${emitStackReadExpr(ctx, fieldPath, tyIdx, unTupleIfW, uLabelTyIdx)}`);
 }
 // Emit a TS "write {expr of type ty} to a stack" expression compatible with @ton/core TupleItem.
 // Used to pass getters arguments, since contract getters work via the stack, not serialization.
 // Parameter `tsExpr` is a valid expression: "p1.field", "p2[0]", "ith" (inside a callback), and other.
-function emitStackWriteItems(ctx, tsExpr, ty, tupleIfW = false) {
+function emitStackWriteItems(ctx, tsExpr, tyIdx, tupleIfW = false, uLabelTyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     if (tupleIfW) { // inside `array<T>` or `[T, ...]`, if T is non-primitive, it's a sub-tuple
-        if ((0, types_kernel_1.calcWidthOnStack)(ctx.symbols, ty) === 1) {
-            return emitStackWriteItems(ctx, tsExpr, ty, false);
+        if ((0, types_kernel_1.calcWidthOnStack)(ctx.symbols, tyIdx) === 1) {
+            return emitStackWriteItems(ctx, tsExpr, tyIdx, false, uLabelTyIdx);
         }
         let buf = new formatting_1.OutBuf();
         buf.push(`{ type: 'tuple', items: [`);
-        for (let line of emitStackWriteItems(ctx, tsExpr, ty, false)) {
+        for (let line of emitStackWriteItems(ctx, tsExpr, tyIdx, false, uLabelTyIdx)) {
             buf.push(line + ',');
         }
         buf.push(`]}`);
@@ -141,17 +144,17 @@ function emitStackWriteItems(ctx, tsExpr, ty, tupleIfW = false) {
         case 'coins': return [`{ type: 'int', value: ${tsExpr} }`];
         case 'bool': return [`{ type: 'int', value: (${tsExpr} ? -1n : 0n) }`];
         case 'cell': return [`{ type: 'cell', cell: ${tsExpr} }`];
-        case 'builder': return [`{ type: 'builder', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
+        case 'builder': return [`{ type: 'builder', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, tyIdx)} }`];
         case 'slice': return [`{ type: 'slice', cell: ${codegen_ctx_1.RUNTIME.beginCell}().storeSlice(${tsExpr}).endCell() }`];
         case 'string': return [`{ type: 'cell', cell: ${codegen_ctx_1.RUNTIME.beginCell}().storeStringTail(${tsExpr}).endCell() }`];
-        case 'remaining': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
-        case 'address': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
-        case 'addressOpt': return emitStackWriteItems(ctx, tsExpr, { kind: 'nullable', inner: { kind: 'address' } });
-        case 'addressExt': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
-        case 'addressAny': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
-        case 'bitsN': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
+        case 'remaining': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, tyIdx)} }`];
+        case 'address': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, tyIdx)} }`];
+        case 'addressOpt': return [`${tsExpr} === null ? { type: 'null' } : { type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, tyIdx)} }`];
+        case 'addressExt': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, tyIdx)} }`];
+        case 'addressAny': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, tyIdx)} }`];
+        case 'bitsN': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, tyIdx)} }`];
         case 'nullLiteral': return [`{ type: 'null' }`];
-        case 'callable': throw new unsupported_errors_1.NotSupportedTypeOnStack(ty, tsExpr);
+        case 'callable': throw new unsupported_errors_1.NotSupportedTypeOnStack((0, types_kernel_1.renderTy)(ctx.symbols, tyIdx), tsExpr);
         case 'void': return [];
         case 'unknown': return [tsExpr];
         case 'nullable': {
@@ -164,22 +167,22 @@ function emitStackWriteItems(ctx, tsExpr, ty, tupleIfW = false) {
                 }
                 buf.push(`{ type: 'int', value: 0n },`);
                 buf.push(`] : [`);
-                emitStackWriteItems(ctx, tsExpr, ty.inner).forEach(w => buf.push(w + ','));
+                emitStackWriteItems(ctx, tsExpr, ty.inner_ty_idx).forEach(w => buf.push(w + ','));
                 buf.push(`{ type: 'int', value: ${ty.stack_type_id}n },`);
                 buf.push(`]`);
                 buf.push(`) as c.TupleItem[]`);
                 return [buf.toString()];
             }
-            return [`${tsExpr} === null ? { type: 'null' } : ${emitStackWriteItems(ctx, tsExpr, ty.inner)[0]}`];
+            return [`${tsExpr} === null ? { type: 'null' } : ${emitStackWriteItems(ctx, tsExpr, ty.inner_ty_idx)[0]}`];
         }
-        case 'cellOf': return [`{ type: 'cell', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, `${tsExpr}.ref`, ty.inner)} }`];
-        case 'arrayOf': return [`{ type: 'tuple', items: ${tsExpr}.map(${formatting_1.OutBuf.onNewLine(`(ith) => (${emitStackWriteItems(ctx, 'ith', ty.inner, true)})`)})}`];
-        case 'tensor': return ty.items.flatMap((item, idx) => emitStackWriteItems(ctx, `${tsExpr}[${idx}]`, item));
+        case 'cellOf': return [`{ type: 'cell', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, `${tsExpr}.ref`, ty.inner_ty_idx)} }`];
+        case 'arrayOf': return [`{ type: 'tuple', items: ${tsExpr}.map(${formatting_1.OutBuf.onNewLine(`(ith) => (${emitStackWriteItems(ctx, 'ith', ty.inner_ty_idx, true)})`)})}`];
+        case 'tensor': return ty.items_ty_idx.flatMap((ty_idx, idx) => emitStackWriteItems(ctx, `${tsExpr}[${idx}]`, ty_idx));
         case 'shapedTuple': {
             let buf = new formatting_1.OutBuf();
             buf.push(`{ type: 'tuple', items: [`);
-            for (let i = 0; i < ty.items.length; ++i) {
-                buf.push(emitStackWriteItems(ctx, `${tsExpr}[${i}]`, ty.items[i], true)[0] + ',');
+            for (let i = 0; i < ty.items_ty_idx.length; ++i) {
+                buf.push(emitStackWriteItems(ctx, `${tsExpr}[${i}]`, ty.items_ty_idx[i], true)[0] + ',');
             }
             buf.push(']}');
             return [buf.toString()];
@@ -187,32 +190,30 @@ function emitStackWriteItems(ctx, tsExpr, ty, tupleIfW = false) {
         case 'lispListOf': {
             let buf = new formatting_1.OutBuf();
             buf.push(`${tsExpr}.reduceRight((tail, head) => ({ type: 'tuple', items: [`);
-            buf.push(emitStackWriteItems(ctx, `head`, ty.inner, true)[0] + ',');
+            buf.push(emitStackWriteItems(ctx, `head`, ty.inner_ty_idx, true)[0] + ',');
             buf.push('tail');
             buf.push(`]}), { type: 'null' } as c.TupleItem)`);
             return [buf.toString()];
         }
-        case 'mapKV': return [`${tsExpr}.size === 0 ? { type: 'null' } : { type: 'cell', cell: ${codegen_ctx_1.RUNTIME.beginCell}().storeDictDirect<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.k, ty.v)}>(${tsExpr}, ${(0, emit_pack_unpack_1.emitDictKVSerializers)(ctx, tsExpr, ty.k, ty.v)}).endCell() }`];
+        case 'mapKV': return [`${tsExpr}.size === 0 ? { type: 'null' } : { type: 'cell', cell: ${codegen_ctx_1.RUNTIME.beginCell}().storeDictDirect<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.key_ty_idx, ty.value_ty_idx)}>(${tsExpr}, ${(0, emit_pack_unpack_1.emitDictKVSerializers)(ctx, tsExpr, ty.key_ty_idx, ty.value_ty_idx)}).endCell() }`];
         case 'EnumRef': return [`{ type: 'int', value: ${tsExpr} }`];
         case 'StructRef': {
-            const structRef = ctx.symbols.getStruct(ty.struct_name);
-            return structRef.fields.flatMap(f => {
-                const fTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(f.ty, structRef.type_params, ty.type_args) : f.ty;
-                return emitStackWriteItems(ctx, `${tsExpr}.${f.name}`, fTy);
-            });
+            return ctx.symbols.structFieldsOf(tyIdx).flatMap(f => emitStackWriteItems(ctx, `${tsExpr}${(0, formatting_1.safeFieldRead)(f.name)}`, f.ty_idx, false, f.uLabelTyIdx));
         }
         case 'AliasRef': {
-            const aliasRef = ctx.symbols.getAlias(ty.alias_name);
-            const targetTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(aliasRef.target_ty, aliasRef.type_params, ty.type_args) : aliasRef.target_ty;
-            return emitStackWriteItems(ctx, tsExpr, targetTy);
+            const target = ctx.symbols.aliasTargetOf(tyIdx);
+            return emitStackWriteItems(ctx, tsExpr, target.ty_idx, tupleIfW, target.uLabelTyIdx);
         }
-        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} in '${tsExpr}'`);
+        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} at '${tsExpr}'`);
         case 'union': {
-            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
+            if (ty.stack_width === undefined) {
+                throw new Error(`unexpected stack_width=undefined at ${tsExpr}`);
+            }
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants, uLabelTyIdx);
             variants.sort((a, b) => a.stack_type_id - b.stack_type_id); // move `null` variant (if exists) to the top
             let buf = new formatting_1.OutBuf();
             buf.push(`...(`);
-            for (let v of variants) {
+            for (const v of variants) {
                 if (v.labelStr === '')
                     buf.push(`${tsExpr} === null ? [`);
                 else
@@ -220,7 +221,7 @@ function emitStackWriteItems(ctx, tsExpr, ty, tupleIfW = false) {
                 for (let i = 0; i < ty.stack_width - 1 - v.stack_width; ++i) {
                     buf.push(`{ type: 'null' },`);
                 }
-                emitStackWriteItems(ctx, v.hasValueField ? tsExpr + '.value' : tsExpr, v.variant_ty).forEach(w => buf.push(w + ','));
+                emitStackWriteItems(ctx, v.hasValueField ? tsExpr + '.value' : tsExpr, v.variant_ty_idx, false).forEach(w => buf.push(w + ','));
                 buf.push(`{ type: 'int', value: ${v.stack_type_id}n },`);
                 buf.push(`] :`);
             }

package/dist/emit-ts-types.d.ts

@@ -1,6 +1,9 @@
-import type { Ty } from './abi-types';
 import { CodegenCtx } from './codegen-ctx';
 import { UnionVariantLabeled } from './types-kernel';
 export declare function emitUnionLabelAndValue(label: UnionVariantLabeled, contents: string): string;
-export declare function emitTsType(ctx: CodegenCtx, ty: Ty): string;
-export declare function emitDictKVTypeArgs(ctx: CodegenCtx, tyK: Ty, tyV: Ty): string;
+export declare function emitPrefixHex(prefix: {
+    prefix_num: number;
+    prefix_len: number;
+}): string;
+export declare function emitTsType(ctx: CodegenCtx, tyIdx: number): string;
+export declare function emitDictKVTypeArgs(ctx: CodegenCtx, tyKIdx: number, tyVIdx: number): string;

package/dist/emit-ts-types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitUnionLabelAndValue = emitUnionLabelAndValue;
+exports.emitPrefixHex = emitPrefixHex;
 exports.emitTsType = emitTsType;
 exports.emitDictKVTypeArgs = emitDictKVTypeArgs;
 const formatting_1 = require("./formatting");
@@ -10,10 +11,17 @@ const types_kernel_1 = require("./types-kernel");
 function emitUnionLabelAndValue(label, contents) {
     return label.hasValueField ? `{ $: '${label.labelStr}', value: ${contents} }` : contents;
 }
+// given prefix_num=305419896 of prefix_len=32, format a string "0x12345678" (opcode)
+function emitPrefixHex(prefix) {
+    return prefix.prefix_len % 4
+        ? `0b${prefix.prefix_num.toString(2).padStart(prefix.prefix_len, '0')}`
+        : `0x${prefix.prefix_num.toString(16).padStart(prefix.prefix_len / 4, '0')}`;
+}
 // Convert any Tolk type (ABI representation) to a corresponding TypeScript type.
 // Tolk `int32` -> TS `bigint`, but for readability, `type int32 = bigint` is created.
 // `c.` is import @ton/core.
-function emitTsType(ctx, ty) {
+function emitTsType(ctx, tyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     if (ty.kind === 'intN')
         ctx.intNOccurred.add(`int${ty.n}`);
     if (ty.kind === 'uintN')
@@ -54,21 +62,21 @@ function emitTsType(ctx, ty) {
         case 'callable': return `any`;
         case 'void': return `void`;
         case 'unknown': return `c.TupleItem`;
-        case 'nullable': return `${emitTsType(ctx, ty.inner)} | null`;
-        case 'cellOf': return `CellRef<${emitTsType(ctx, ty.inner)}>`;
-        case 'arrayOf': return `array<${emitTsType(ctx, ty.inner)}>`;
-        case 'lispListOf': return `lisp_list<${emitTsType(ctx, ty.inner)}>`;
-        case 'tensor': return `[${ty.items.map(item => emitTsType(ctx, item)).join(', ')}]`;
-        case 'shapedTuple': return `[${ty.items.map(item => emitTsType(ctx, item)).join(', ')}]`;
-        case 'mapKV': return `c.Dictionary<${emitDictKVTypeArgs(ctx, ty.k, ty.v)}>`;
-        case 'EnumRef': return ty.enum_name;
-        case 'StructRef': return (0, formatting_1.safeJsIdent)(ty.struct_name) + (ty.type_args ? `<${ty.type_args.map(ta => emitTsType(ctx, ta)).join(', ')}>` : '');
-        case 'AliasRef': return (0, formatting_1.safeJsIdent)(ty.alias_name) + (ty.type_args ? `<${ty.type_args.map(ta => emitTsType(ctx, ta)).join(', ')}>` : '');
+        case 'nullable': return `${emitTsType(ctx, ty.inner_ty_idx)} | null`;
+        case 'cellOf': return `CellRef<${emitTsType(ctx, ty.inner_ty_idx)}>`;
+        case 'arrayOf': return `array<${emitTsType(ctx, ty.inner_ty_idx)}>`;
+        case 'lispListOf': return `lisp_list<${emitTsType(ctx, ty.inner_ty_idx)}>`;
+        case 'tensor': return `[${ty.items_ty_idx.map(ty_idx => emitTsType(ctx, ty_idx)).join(', ')}]`;
+        case 'shapedTuple': return `[${ty.items_ty_idx.map(ty_idx => emitTsType(ctx, ty_idx)).join(', ')}]`;
+        case 'mapKV': return `c.Dictionary<${emitDictKVTypeArgs(ctx, ty.key_ty_idx, ty.value_ty_idx)}>`;
+        case 'EnumRef': return (0, formatting_1.safeJsIdent)(ty.enum_name);
+        case 'StructRef': return (0, formatting_1.safeJsIdent)(ty.struct_name) + (ty.type_args_ty_idx ? `<${ty.type_args_ty_idx.map(ty_idx => emitTsType(ctx, ty_idx)).join(', ')}>` : '');
+        case 'AliasRef': return (0, formatting_1.safeJsIdent)(ty.alias_name) + (ty.type_args_ty_idx ? `<${ty.type_args_ty_idx.map(ty_idx => emitTsType(ctx, ty_idx)).join(', ')}>` : '');
         case 'genericT': return ty.name_t;
-        case 'union': return (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants).map(v => emitUnionLabelAndValue(v, emitTsType(ctx, v.variant_ty))).join(' | ');
+        case 'union': return (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants).map(v => emitUnionLabelAndValue(v, emitTsType(ctx, v.variant_ty_idx))).join(' | ');
     }
 }
 // Emit c.Dictionary<K, V> (K and V — inside brackets, two types separated by comma).
-function emitDictKVTypeArgs(ctx, tyK, tyV) {
-    return emitTsType(ctx, tyK) + ', ' + emitTsType(ctx, tyV);
+function emitDictKVTypeArgs(ctx, tyKIdx, tyVIdx) {
+    return emitTsType(ctx, tyKIdx) + ', ' + emitTsType(ctx, tyVIdx);
 }

package/dist/generate-ts-wrappers.d.ts

@@ -4,4 +4,6 @@ import type { ContractABI } from './abi';
  * and returns the full TypeScript wrapper with all serializers, send, and get methods.
  * @throws CantGenerateWrappersAtAll
  */
-export declare function generateTypeScriptFileForContract(contract: ContractABI): string;
+export declare function generateTypeScriptFileForContract(abi: ContractABI & {
+    code_boc64: string;
+}): string;