gen-typescript-from-tolk-dev 0.3.1 → 0.3.2

package/dist/abi-types.d.ts

@@ -145,10 +145,12 @@ export interface ABIStruct {
     fields: {
         name: string;
         ty_idx: number;
+        client_ty_idx?: number;
         default_value?: ABIConstExpression;
         description?: string;
     }[];
     custom_pack_unpack?: ABICustomSerializers;
+    description?: string;
 }
 export interface ABIAlias {
     kind: 'alias';
@@ -157,6 +159,7 @@ export interface ABIAlias {
     target_ty_idx: number;
     type_params?: string[];
     custom_pack_unpack?: ABICustomSerializers;
+    description?: string;
 }
 export interface ABIEnum {
     kind: 'enum';
@@ -168,6 +171,7 @@ export interface ABIEnum {
         value: bigint_as_string;
     }[];
     custom_pack_unpack?: ABICustomSerializers;
+    description?: string;
 }
 export interface ABIStructInstantiation {
     ty_idx: number;

package/dist/abi.d.ts

@@ -13,20 +13,16 @@ export interface ABIGetMethod {
 }
 export interface ABIInternalMessage {
     body_ty_idx: number;
-    description?: string;
 }
 export interface ABIExternalMessage {
     body_ty_idx: number;
-    description?: string;
 }
 export interface ABIOutgoingMessage {
     body_ty_idx: number;
-    description?: string;
 }
 export interface ABIStorage {
     storage_ty_idx?: number;
     storage_at_deployment_ty_idx?: number;
-    description?: string;
 }
 export interface ABIThrownError {
     kind: 'plain_int' | 'constant' | 'enum_member';

package/dist/dynamic-debug-print.js

@@ -109,7 +109,7 @@ function debugFormat(ctx, r, fieldPath, tyIdx, unTupleIfW = false) {
             return `${ty.enum_name}(${value})`;
         }
         case 'StructRef': {
-            let fields = ctx.symbols.structFieldsOf(tyIdx);
+            let fields = ctx.symbols.structFieldsOf(tyIdx, true);
             if (fields.length === 0) {
                 return `${ty.struct_name} {}`;
             }

package/dist/dynamic-get-methods.js

@@ -290,7 +290,7 @@ function dynamicConstruct(ctx, fieldPath, tyIdx, v, tupleIfW = false, uLabelTyId
         }
         case 'StructRef': {
             (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
-            return ctx.symbols.structFieldsOf(tyIdx).flatMap(f => dynamicConstruct(ctx, `${fieldPath}.${f.name}`, f.ty_idx, v[f.name], false, f.uLabelTyIdx));
+            return ctx.symbols.structFieldsOf(tyIdx, true).flatMap(f => dynamicConstruct(ctx, `${fieldPath}.${f.name}`, f.ty_idx, v[f.name], false, f.uLabelTyIdx));
         }
         case 'AliasRef': {
             const target = ctx.symbols.aliasTargetOf(tyIdx);
@@ -395,7 +395,7 @@ function dynamicParse(ctx, r, fieldPath, tyIdx, unTupleIfW = false, uLabelTyIdx)
         case 'EnumRef': return r.readBigInt();
         case 'StructRef': {
             let result = { $: ty.struct_name };
-            for (let f of ctx.symbols.structFieldsOf(tyIdx)) {
+            for (let f of ctx.symbols.structFieldsOf(tyIdx, true)) {
                 result[f.name] = dynamicParse(ctx, r, `${fieldPath}.${f.name}`, f.ty_idx, false, f.uLabelTyIdx);
             }
             return result;

package/dist/dynamic-serialization.js

@@ -244,7 +244,7 @@ function dynamicPack(ctx, fieldPath, tyIdx, v, b, uLabelTyIdx) {
             if (structRef.prefix) {
                 b.storeUint(structRef.prefix.prefix_num, structRef.prefix.prefix_len);
             }
-            for (let f of ctx.symbols.structFieldsOf(tyIdx)) {
+            for (let f of ctx.symbols.structFieldsOf(tyIdx, false)) {
                 try {
                     dynamicPack(ctx, `${fieldPath}.${f.name}`, f.ty_idx, v[f.name], b, f.uLabelTyIdx);
                 }
@@ -387,7 +387,7 @@ function dynamicUnpack(ctx, fieldPath, tyIdx, s, uLabelTyIdx) {
                     throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, `incorrect prefix for '${ty.struct_name}', expected ${(0, emit_ts_types_1.emitPrefixHex)(structRef.prefix)}`);
                 }
             }
-            for (let f of ctx.symbols.structFieldsOf(tyIdx)) {
+            for (let f of ctx.symbols.structFieldsOf(tyIdx, false)) {
                 try {
                     result[f.name] = dynamicUnpack(ctx, `${fieldPath}.${f.name}`, f.ty_idx, s, f.uLabelTyIdx);
                 }

package/dist/emit-pack-unpack.js

@@ -34,7 +34,7 @@ function emitLoadOfStruct(ctx, structRef, instantiationTyIdx) {
     }
     buf.push(`return {`);
     buf.push(`$: '${structRef.name}',`);
-    for (let f of ctx.symbols.structFieldsOf(instantiationTyIdx)) {
+    for (let f of ctx.symbols.structFieldsOf(instantiationTyIdx, false)) {
         buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${emitLoadExpr(ctx, `${(0, formatting_1.safeJsIdent)(structRef.name)}${(0, formatting_1.safeFieldRead)(f.name)}`, f.ty_idx, f.uLabelTyIdx)},`);
     }
     buf.push('}');
@@ -89,9 +89,9 @@ function emitLoadExpr(ctx, fieldPath, tyIdx, uLabelTyIdx) {
         case 'nullLiteral': return `null`;
         case 'void': return `void 0`;
         case 'nullable': return `s.loadBoolean() ? ${emitLoadExpr(ctx, fieldPath, ty.inner_ty_idx)} : null`;
-        case 'cellOf': return `${codegen_ctx_1.RUNTIME.loadCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(s, ${emitLoadCallback(ctx, fieldPath, ty.inner_ty_idx)})`;
-        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.loadArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner_ty_idx)})`;
-        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.loadLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner_ty_idx)})`;
+        case 'cellOf': return `${codegen_ctx_1.RUNTIME.loadCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, false)}>(s, ${emitLoadCallback(ctx, fieldPath, ty.inner_ty_idx)})`;
+        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.loadArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, false)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner_ty_idx)})`;
+        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.loadLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, false)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner_ty_idx)})`;
         case 'tensor': return `[${ty.items_ty_idx.map((ty_idx, i) => emitLoadExpr(ctx, `${fieldPath}[${i}]`, ty_idx)).join(', ')}]`;
         case 'shapedTuple': return `[${ty.items_ty_idx.map((ty_idx, i) => emitLoadExpr(ctx, `${fieldPath}[${i}]`, ty_idx)).join(', ')}]`;
         case 'mapKV': return `c.Dictionary.load<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.key_ty_idx, ty.value_ty_idx)}>(${emitDictKVSerializers(ctx, fieldPath, ty.key_ty_idx, ty.value_ty_idx)}, s)`;
@@ -113,7 +113,9 @@ function emitLoadExpr(ctx, fieldPath, tyIdx, uLabelTyIdx) {
         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, uLabelTyIdx);
-            const isEither01 = variants.length === 2 && variants[0].prefix_num === 0 && variants[1].prefix_num === 1;
+            const isEither01 = variants.length === 2
+                && variants[0].is_prefix_implicit && variants[1].is_prefix_implicit
+                && variants[0].prefix_num === 0 && variants[1].prefix_num === 1;
             if (isEither01) {
                 const l = (0, emit_ts_types_1.emitUnionLabelAndValue)(variants[0], emitLoadExpr(ctx, fieldPath, variants[0].variant_ty_idx));
                 const r = (0, emit_ts_types_1.emitUnionLabelAndValue)(variants[1], emitLoadExpr(ctx, fieldPath, variants[1].variant_ty_idx));
@@ -165,7 +167,7 @@ function emitStoreOfStruct(ctx, tsExpr, structRef, instantiationTyIdx) {
     if (structRef.prefix) {
         buf.push(`b.storeUint(${(0, emit_ts_types_1.emitPrefixHex)(structRef.prefix)}, ${structRef.prefix.prefix_len});`);
     }
-    for (let f of ctx.symbols.structFieldsOf(instantiationTyIdx)) {
+    for (let f of ctx.symbols.structFieldsOf(instantiationTyIdx, false)) {
         buf.push(emitStoreStatement(ctx, `${tsExpr}${(0, formatting_1.safeFieldRead)(f.name)}`, f.ty_idx, f.uLabelTyIdx));
     }
     return buf.toString();
@@ -215,10 +217,10 @@ function emitStoreStatement(ctx, tsExpr, tyIdx, uLabelTyIdx) {
         case 'addressAny': return `${codegen_ctx_1.RUNTIME.storeTolkAddressAny}(${tsExpr}, b);`;
         case 'bitsN': return `${codegen_ctx_1.RUNTIME.storeTolkBitsN}(${tsExpr}, ${ty.n}, b);`;
         case 'void': return ``;
-        case 'nullable': return `${codegen_ctx_1.RUNTIME.storeTolkNullable}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
-        case 'cellOf': return `${codegen_ctx_1.RUNTIME.storeCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
-        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.storeArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
-        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.storeLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
+        case 'nullable': return `${codegen_ctx_1.RUNTIME.storeTolkNullable}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, false)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
+        case 'cellOf': return `${codegen_ctx_1.RUNTIME.storeCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, false)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
+        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.storeArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, false)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
+        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.storeLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, false)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
         case 'tensor': return ty.items_ty_idx.length ? ty.items_ty_idx.map((ty_idx, i) => emitStoreStatement(ctx, `${tsExpr}[${i}]`, ty_idx)).join('\n') : `{}`;
         case 'shapedTuple': return ty.items_ty_idx.length ? ty.items_ty_idx.map((ty_idx, i) => emitStoreStatement(ctx, `${tsExpr}[${i}]`, ty_idx)).join('\n') : `{}`;
         case 'mapKV': return `b.storeDict<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.key_ty_idx, ty.value_ty_idx)}>(${tsExpr}, ${emitDictKVSerializers(ctx, tsExpr, ty.key_ty_idx, ty.value_ty_idx)});`;
@@ -295,7 +297,7 @@ function emitStoreCallback(ctx, tyIdx) {
 // Parameter `tsExpr` is a valid expression: "self.field", "v" (inside a callback), and other.
 function emitMakeCellFromExpr(ctx, tsExpr, tyIdx, disableShortHand = false) {
     if (disableShortHand) {
-        return `${codegen_ctx_1.RUNTIME.makeCellFrom}<${(0, emit_ts_types_1.emitTsType)(ctx, tyIdx)}>(${tsExpr}, ${emitStoreCallback(ctx, tyIdx)})`;
+        return `${codegen_ctx_1.RUNTIME.makeCellFrom}<${(0, emit_ts_types_1.emitTsType)(ctx, tyIdx, false)}>(${tsExpr}, ${emitStoreCallback(ctx, tyIdx)})`;
     }
     const ty = ctx.symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
@@ -324,12 +326,12 @@ function emitMakeCellFromExpr(ctx, tsExpr, tyIdx, disableShortHand = false) {
 function emitCallToCreateMethodExpr(ctx, bodyArg, tyIdx) {
     const ty = ctx.symbols.tyByIdx(tyIdx);
     if (ty.kind === 'StructRef') {
-        let fields = ctx.symbols.structFieldsOf(tyIdx);
+        let fields = ctx.symbols.structFieldsOf(tyIdx, false);
         if (fields.length === 0) {
             bodyArg = ''; // create() is without arguments, body is an empty object
         }
         if (ty.type_args_ty_idx) {
-            return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.create<${ty.type_args_ty_idx.map(ty_idx => (0, emit_ts_types_1.emitTsType)(ctx, ty_idx)).join(', ')}>(${bodyArg})`;
+            return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.create<${ty.type_args_ty_idx.map(ty_idx => (0, emit_ts_types_1.emitTsType)(ctx, ty_idx, false)).join(', ')}>(${bodyArg})`;
         }
         return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.create(${bodyArg})`;
     }
@@ -364,7 +366,7 @@ function emitDictValueSerializer(ctx, fieldPath, tyVIdx) {
     if (tyV.kind === 'cell')
         return `c.Dictionary.Values.Cell()`;
     ctx.has_customDictV = true;
-    return `${codegen_ctx_1.RUNTIME.createDictionaryValue}<${(0, emit_ts_types_1.emitTsType)(ctx, tyVIdx)}>(${emitLoadCallback(ctx, fieldPath, tyVIdx)}, ${emitStoreCallback(ctx, tyVIdx)})`;
+    return `${codegen_ctx_1.RUNTIME.createDictionaryValue}<${(0, emit_ts_types_1.emitTsType)(ctx, tyVIdx, false)}>(${emitLoadCallback(ctx, fieldPath, tyVIdx)}, ${emitStoreCallback(ctx, tyVIdx)})`;
 }
 // Emit (de)serializers for c.Dictionary<K, V> (two arguments separated by a comma).
 function emitDictKVSerializers(ctx, fieldPath, tyKIdx, tyVIdx) {

package/dist/emit-stack-rw.js

@@ -28,7 +28,7 @@ function emitStackReadExpr(ctx, fieldPath, tyIdx, unTupleIfW = false, uLabelTyId
     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, tyIdx);
         if (wOnStack !== 1) {
-            return `r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, tyIdx)}>(${wOnStack}, ${emitStackReadCallback(ctx, fieldPath, tyIdx, false, uLabelTyIdx)})`;
+            return `r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, tyIdx, true)}>(${wOnStack}, ${emitStackReadCallback(ctx, fieldPath, tyIdx, false, uLabelTyIdx)})`;
         }
     }
     switch (ty.kind) {
@@ -55,13 +55,13 @@ function emitStackReadExpr(ctx, fieldPath, tyIdx, unTupleIfW = false, uLabelTyId
         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_idx)}>(${ty.stack_width}, ${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, false)})`;
+                return `r.readWideNullable<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, true)}>(${ty.stack_width}, ${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, false)})`;
             }
-            return `r.readNullable<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, false)})`;
+            return `r.readNullable<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, true)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, false)})`;
         }
-        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 'cellOf': return `r.readCellRef<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, false)}>(${(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, true)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, true)})`;
+        case 'lispListOf': return `r.readLispListOf<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx, true)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner_ty_idx, true)})`;
         case 'tensor': {
             let buf = new formatting_1.OutBuf();
             buf.push(`[`);
@@ -73,7 +73,7 @@ function emitStackReadExpr(ctx, fieldPath, tyIdx, unTupleIfW = false, uLabelTyId
         }
         case 'shapedTuple': {
             let buf = new formatting_1.OutBuf();
-            buf.push(`r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, tyIdx)}>(${ty.items_ty_idx.length}, (r) => [`);
+            buf.push(`r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, tyIdx, true)}>(${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) + ',');
             }
@@ -86,7 +86,7 @@ function emitStackReadExpr(ctx, fieldPath, tyIdx, unTupleIfW = false, uLabelTyId
             let buf = new formatting_1.OutBuf();
             buf.push(`({`);
             buf.push(`$: '${ty.struct_name}',`);
-            for (let f of ctx.symbols.structFieldsOf(tyIdx)) {
+            for (let f of ctx.symbols.structFieldsOf(tyIdx, true)) {
                 buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${emitStackReadExpr(ctx, `${fieldPath}.${f.name}`, f.ty_idx, false, f.uLabelTyIdx)},`);
             }
             buf.push(`})`);
@@ -103,7 +103,7 @@ function emitStackReadExpr(ctx, fieldPath, tyIdx, unTupleIfW = false, uLabelTyId
             }
             const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants, uLabelTyIdx);
             let buf = new formatting_1.OutBuf();
-            let tsUniTypeStr = variants.map(v => (0, emit_ts_types_1.emitUnionLabelAndValue)(v, (0, emit_ts_types_1.emitTsType)(ctx, v.variant_ty_idx))).join(' | ');
+            let tsUniTypeStr = variants.map(v => (0, emit_ts_types_1.emitUnionLabelAndValue)(v, (0, emit_ts_types_1.emitTsType)(ctx, v.variant_ty_idx, true))).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_idx, false, uLabelTyIdx)}],`);
@@ -198,7 +198,7 @@ function emitStackWriteItems(ctx, tsExpr, tyIdx, tupleIfW = false, uLabelTyIdx)
         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': {
-            return ctx.symbols.structFieldsOf(tyIdx).flatMap(f => emitStackWriteItems(ctx, `${tsExpr}${(0, formatting_1.safeFieldRead)(f.name)}`, f.ty_idx, false, f.uLabelTyIdx));
+            return ctx.symbols.structFieldsOf(tyIdx, true).flatMap(f => emitStackWriteItems(ctx, `${tsExpr}${(0, formatting_1.safeFieldRead)(f.name)}`, f.ty_idx, false, f.uLabelTyIdx));
         }
         case 'AliasRef': {
             const target = ctx.symbols.aliasTargetOf(tyIdx);

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

@@ -5,5 +5,5 @@ export declare function emitPrefixHex(prefix: {
     prefix_num: number;
     prefix_len: number;
 }): string;
-export declare function emitTsType(ctx: CodegenCtx, tyIdx: number): string;
+export declare function emitTsType(ctx: CodegenCtx, tyIdx: number, isForStack: boolean): string;
 export declare function emitDictKVTypeArgs(ctx: CodegenCtx, tyKIdx: number, tyVIdx: number): string;

package/dist/emit-ts-types.js

@@ -20,7 +20,7 @@ function emitPrefixHex(prefix) {
 // 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, tyIdx) {
+function emitTsType(ctx, tyIdx, isForStack) {
     const ty = ctx.symbols.tyByIdx(tyIdx);
     if (ty.kind === 'intN')
         ctx.intNOccurred.add(`int${ty.n}`);
@@ -62,21 +62,37 @@ function emitTsType(ctx, tyIdx) {
         case 'callable': return `any`;
         case 'void': return `void`;
         case 'unknown': return `c.TupleItem`;
-        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 'nullable': return `${emitTsType(ctx, ty.inner_ty_idx, isForStack)} | null`;
+        case 'cellOf': return `CellRef<${emitTsType(ctx, ty.inner_ty_idx, false)}>`;
+        case 'arrayOf': return `array<${emitTsType(ctx, ty.inner_ty_idx, isForStack)}>`;
+        case 'lispListOf': return `lisp_list<${emitTsType(ctx, ty.inner_ty_idx, isForStack)}>`;
+        case 'tensor': return `[${ty.items_ty_idx.map(ty_idx => emitTsType(ctx, ty_idx, isForStack)).join(', ')}]`;
+        case 'shapedTuple': return `[${ty.items_ty_idx.map(ty_idx => emitTsType(ctx, ty_idx, isForStack)).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 'StructRef': {
+            const stackFields = ctx.symbols.structFieldsOf(tyIdx, true);
+            const anyFieldHasAbiClientType = stackFields.some(f => f.client_ty_idx !== undefined);
+            if (!isForStack || !anyFieldHasAbiClientType) {
+                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, isForStack)).join(', ')}>` : '');
+            }
+            // On stack, @abi.clientType does not apply: getters return the original field types.
+            // The exported interface (serializable) uses client types, so emit an anonymous stack-shaped object.
+            const buf = new formatting_1.OutBuf();
+            buf.push(`{`);
+            buf.push(`readonly $: '${ty.struct_name}'`);
+            for (const f of stackFields) {
+                buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${emitTsType(ctx, f.ty_idx, true)}`);
+            }
+            buf.push(`}`);
+            return buf.toString();
+        }
+        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, isForStack)).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_idx))).join(' | ');
+        case 'union': return (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants).map(v => emitUnionLabelAndValue(v, emitTsType(ctx, v.variant_ty_idx, isForStack))).join(' | ');
     }
 }
 // Emit c.Dictionary<K, V> (K and V — inside brackets, two types separated by comma).
 function emitDictKVTypeArgs(ctx, tyKIdx, tyVIdx) {
-    return emitTsType(ctx, tyKIdx) + ', ' + emitTsType(ctx, tyVIdx);
+    return emitTsType(ctx, tyKIdx, false) + ', ' + emitTsType(ctx, tyVIdx, false);
 }

package/dist/generate-ts-wrappers.js

@@ -56,9 +56,9 @@ function tolkStructToTypeScript(ctx, s, buf) {
     buf.push(renderStructDocComment(ctx, s));
     buf.push(`export interface ${structName}${genericTs} {`);
     buf.push(`readonly $: '${s.name}'`);
-    for (const f of s.fields) {
+    for (const f of ctx.symbols.structFieldsOf(s.ty_idx, false)) {
         let comment = f.default_value ? ` /* = ${(0, emit_field_defs_1.emitFieldDefaultInComment)(ctx, f.default_value)} */` : '';
-        buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${(0, emit_ts_types_1.emitTsType)(ctx, f.ty_idx)}${comment}`);
+        buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${(0, emit_ts_types_1.emitTsType)(ctx, f.ty_idx, false)}${comment}`);
     }
     buf.push('}');
     buf.emptyLine();
@@ -71,7 +71,7 @@ function tolkStructToTypeScript(ctx, s, buf) {
     buf.push(`create${genericTs}(${argsParam}): ${structName}${genericTs} {`);
     buf.push(`return {`);
     buf.push(`$: '${s.name}',`);
-    for (let f of s.fields.filter(f => f.default_value && (0, emit_field_defs_1.isDefaultValueSupported)(ctx, f.ty_idx))) {
+    for (let f of ctx.symbols.structFieldsOf(s.ty_idx, false).filter(f => f.default_value && (0, emit_field_defs_1.isDefaultValueSupported)(ctx, f.ty_idx))) {
         let needAsAny = ctx.symbols.tyByIdx(f.ty_idx).kind === 'genericT';
         buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${(0, emit_field_defs_1.emitFieldDefault)(ctx, f.default_value)}${needAsAny ? ' as any' : ''},`);
     }
@@ -118,12 +118,12 @@ function tolkAliasToTypeScript(ctx, a, buf) {
     if (targetTy.kind === 'union') {
         buf.push(`export type ${aliasName}${genericTs} =`).indent();
         for (const v of (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, targetTy.variants)) {
-            buf.push('| ' + (0, emit_ts_types_1.emitUnionLabelAndValue)(v, (0, emit_ts_types_1.emitTsType)(ctx, v.variant_ty_idx)));
+            buf.push('| ' + (0, emit_ts_types_1.emitUnionLabelAndValue)(v, (0, emit_ts_types_1.emitTsType)(ctx, v.variant_ty_idx, false)));
         }
         buf.outdent();
     }
     else {
-        buf.push(`export type ${aliasName}${genericTs} = ${(0, emit_ts_types_1.emitTsType)(ctx, a.target_ty_idx)}`);
+        buf.push(`export type ${aliasName}${genericTs} = ${(0, emit_ts_types_1.emitTsType)(ctx, a.target_ty_idx, false)}`);
     }
     if (ps) { // generic aliases don't have `fromSlice` and `store`
         return buf.toString();
@@ -191,9 +191,9 @@ function snakeCaseToCamelCase(snakeString) {
 function structParameterNoLabel(ctx, structTyIdx) {
     let declBuf = new formatting_1.OutBuf();
     declBuf.push(`{`);
-    for (let f of ctx.symbols.structFieldsOf(structTyIdx)) {
+    for (let f of ctx.symbols.structFieldsOf(structTyIdx, false)) {
         let comment = f.default_value ? ` /* = ${(0, emit_field_defs_1.emitFieldDefaultInComment)(ctx, f.default_value)} */` : '';
-        declBuf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}${f.default_value && (0, emit_field_defs_1.isDefaultValueSupported)(ctx, f.ty_idx) ? '?' : ''}: ${(0, emit_ts_types_1.emitTsType)(ctx, f.ty_idx)}${comment}`);
+        declBuf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}${f.default_value && (0, emit_field_defs_1.isDefaultValueSupported)(ctx, f.ty_idx) ? '?' : ''}: ${(0, emit_ts_types_1.emitTsType)(ctx, f.ty_idx, false)}${comment}`);
     }
     declBuf.push(`}`);
     return declBuf.toString();
@@ -205,7 +205,7 @@ function generateFromStorageMethod(ctx, tyIdx, contractName) {
         return '';
     }
     const ty = ctx.symbols.tyByIdx(tyIdx);
-    let storageParamT = (0, emit_ts_types_1.emitTsType)(ctx, tyIdx);
+    let storageParamT = (0, emit_ts_types_1.emitTsType)(ctx, tyIdx, false);
     let bodyArg = 'emptyStorage';
     if (ty.kind === 'StructRef') {
         storageParamT = structParameterNoLabel(ctx, tyIdx);
@@ -228,7 +228,7 @@ function generateFromStorageMethod(ctx, tyIdx, contractName) {
 function generateCreateCellOfMessageMethod(ctx, tyIdx) {
     const ty = ctx.symbols.tyByIdx(tyIdx);
     let functionName = snakeCaseToCamelCase((0, formatting_1.safeJsIdent)(`createCellOf_${(0, types_kernel_1.renderTy)(ctx.symbols, tyIdx)}`));
-    let bodyParamT = (0, emit_ts_types_1.emitTsType)(ctx, tyIdx);
+    let bodyParamT = (0, emit_ts_types_1.emitTsType)(ctx, tyIdx, false);
     let bodyArg = 'body';
     if (ty.kind === 'StructRef') {
         bodyParamT = structParameterNoLabel(ctx, tyIdx);
@@ -245,7 +245,7 @@ function generateCreateCellOfMessageMethod(ctx, tyIdx) {
 function generateSendMethod(ctx, tyIdx) {
     const ty = ctx.symbols.tyByIdx(tyIdx);
     let functionName = snakeCaseToCamelCase((0, formatting_1.safeJsIdent)(`send_${(0, types_kernel_1.renderTy)(ctx.symbols, tyIdx)}`));
-    let bodyParamT = (0, emit_ts_types_1.emitTsType)(ctx, tyIdx);
+    let bodyParamT = (0, emit_ts_types_1.emitTsType)(ctx, tyIdx, false);
     let bodyArg = 'body';
     if (ty.kind === 'StructRef') {
         bodyParamT = structParameterNoLabel(ctx, tyIdx);
@@ -274,17 +274,17 @@ function generateGetMethod(ctx, getM) {
         return (0, formatting_1.safeJsIdent)(collision ? p.name + '_' : p.name);
     });
     let buf = new formatting_1.OutBuf();
-    let paramsStr = nParams ? `, ${getM.parameters.map((p, i) => `${paramNames[i]}: ${(0, emit_ts_types_1.emitTsType)(ctx, p.ty_idx)}${p.default_value ? ` = ${(0, emit_field_defs_1.emitFieldDefault)(ctx, p.default_value)}` : ''}`).join(', ')}` : '';
+    let paramsStr = nParams ? `, ${getM.parameters.map((p, i) => `${paramNames[i]}: ${(0, emit_ts_types_1.emitTsType)(ctx, p.ty_idx, true)}${p.default_value ? ` = ${(0, emit_field_defs_1.emitFieldDefault)(ctx, p.default_value)}` : ''}`).join(', ')}` : '';
     const returnTy = ctx.symbols.tyByIdx(getM.return_ty_idx);
     if (returnTy.kind === 'tensor') {
         buf.push(`async ${functionName}(provider: ContractProvider${paramsStr}): Promise<[`);
         for (let item of returnTy.items_ty_idx) {
-            buf.push((0, emit_ts_types_1.emitTsType)(ctx, item) + ',');
+            buf.push((0, emit_ts_types_1.emitTsType)(ctx, item, true) + ',');
         }
         buf.push(']> {');
     }
     else {
-        buf.push(`async ${functionName}(provider: ContractProvider${paramsStr}): Promise<${(0, emit_ts_types_1.emitTsType)(ctx, getM.return_ty_idx)}> {`);
+        buf.push(`async ${functionName}(provider: ContractProvider${paramsStr}): Promise<${(0, emit_ts_types_1.emitTsType)(ctx, getM.return_ty_idx, true)}> {`);
     }
     let stackW = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, getM.return_ty_idx);
     if (nParams) {

package/dist/types-kernel.d.ts

@@ -11,7 +11,7 @@ export declare class SymTable {
     getAlias(aliasName: string): ABIAlias;
     getEnum(enumName: string): ABIEnum;
     tyByIdx(tyIdx: number): Ty;
-    structFieldsOf(tyIdx: number): (ABIStruct['fields'][number] & {
+    structFieldsOf(tyIdx: number, isForStack: boolean): (ABIStruct['fields'][number] & {
         uLabelTyIdx?: number;
     })[];
     aliasTargetOf(tyIdx: number): {

package/dist/types-kernel.js

@@ -57,7 +57,7 @@ class SymTable {
     // Generic instantiations, e.g. `Wrapper<int32>`:
     // - override original ty_idx (potentially generic) from monomorphic instantiations (with Ts substitutes)
     // - save original ty_idx as uLabelTyIdx in case of generic unions later
-    structFieldsOf(tyIdx) {
+    structFieldsOf(tyIdx, isForStack) {
         const ty = this.tyByIdx(tyIdx);
         if (ty.kind !== 'StructRef') {
             throw new Error(`expected StructRef at ty_idx=${tyIdx}`);
@@ -74,6 +74,13 @@ class SymTable {
                 uLabelTyIdx: f.ty_idx,
             }));
         }
+        if (!isForStack) {
+            fields = fields.map(f => f.client_ty_idx === undefined ? f : ({
+                ...f,
+                ty_idx: f.client_ty_idx, // @abi.clientType is denied for generic fields
+                uLabelTyIdx: undefined, // that's why no monomorphic representations exist
+            }));
+        }
         return fields;
     }
     // Get target of an alias, `tyIdx` points to "AliasRef".
@@ -255,7 +262,7 @@ function calcWidthOnStack(symbols, tyIdx) {
         }
         case 'StructRef': {
             // a struct is a named tensor: fields one by one;
-            const fields = symbols.structFieldsOf(tyIdx);
+            const fields = symbols.structFieldsOf(tyIdx, true);
             return fields.map(f => calcWidthOnStack(symbols, f.ty_idx)).reduce((p, c) => p + c, 0);
         }
         case 'AliasRef': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gen-typescript-from-tolk-dev",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Generate TypeScript wrappers from Tolk ABI",
   "author": "TON Core",
   "license": "MIT",