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

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/out-template.generated.d.ts

@@ -1 +1 @@
-export declare const OUT_TEMPLATE = "// AUTO-GENERATED, do not edit\n// it's a TypeScript wrapper for a CONTRACT_CLASS_NAME contract in Tolk\n/* eslint-disable */\n\nimport * as c from '@ton/core';\nimport { beginCell, ContractProvider, Sender, SendMode } from '@ton/core';\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   predefined types and functions\n//\n\n// {{if:has_remaining}}\ntype RemainingBitsAndRefs = c.Slice\n// {{/if:has_remaining}}\n\n// {{if:has_addressAny}}\nexport type any_address = c.Address | c.ExternalAddress | 'none'\n// {{/if:has_addressAny}}\n\n// {{if:has_arrayOf}}\ntype array<T> = T[]\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\n// TypeScript wrappers flatten a TVM linked list `[1 [2 [3 null]]]` to `[1 2 3]`\ntype lisp_list<T> = T[]\n// {{/if:has_lispListOf}}\n\ntype StoreCallback<T> = (obj: T, b: c.Builder) => void\ntype LoadCallback<T> = (s: c.Slice) => T\n\nexport type CellRef<T> = {\n    ref: T\n}\n\nfunction makeCellFrom<T>(self: T, storeFn_T: StoreCallback<T>): c.Cell {\n    let b = beginCell();\n    storeFn_T(self, b);\n    return b.endCell();\n}\n\nfunction loadAndCheckPrefix32(s: c.Slice, expected: number, structName: string): void {\n    let prefix = s.loadUint(32);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected 0x${expected.toString(16).padStart(8, '0')}, got 0x${prefix.toString(16).padStart(8, '0')}`);\n    }\n}\n\n// {{if:has_non32Prefixes}}\nfunction formatPrefix(prefixNum: number, prefixLen: number): string {\n    return prefixLen % 4 ? `0b${prefixNum.toString(2).padStart(prefixLen, '0')}` : `0x${prefixNum.toString(16).padStart(prefixLen / 4, '0')}`;\n}\n\nfunction loadAndCheckPrefix(s: c.Slice, expected: number, prefixLen: number, structName: string): void {\n    let prefix = s.loadUint(prefixLen);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected ${formatPrefix(expected, prefixLen)}, got ${formatPrefix(prefix, prefixLen)}`);\n    }\n}\n// {{/if:has_non32Prefixes}}\n\nfunction lookupPrefix(s: c.Slice, expected: number, prefixLen: number): boolean {\n    return s.remainingBits >= prefixLen && s.preloadUint(prefixLen) === expected;\n}\n\n// {{if:has_implicitUnionPrefix}}\nfunction lookupPrefixAndEat(s: c.Slice, expected: number, prefixLen: number): boolean {\n    if (lookupPrefix(s, expected, prefixLen)) {\n        s.skip(prefixLen);\n        return true;\n    }\n    return false;\n}\n// {{/if:has_implicitUnionPrefix}}\n\nfunction throwNonePrefixMatch(fieldPath: string): never {\n    throw new Error(`Incorrect prefix for '${fieldPath}': none of variants matched`);\n}\n\nfunction storeCellRef<T>(cell: CellRef<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let b_ref = c.beginCell();\n    storeFn_T(cell.ref, b_ref);\n    b.storeRef(b_ref.endCell());\n}\n\nfunction loadCellRef<T>(s: c.Slice, loadFn_T: LoadCallback<T>): CellRef<T> {\n    let s_ref = s.loadRef().beginParse();\n    return { ref: loadFn_T(s_ref) };\n}\n\n// {{if:has_addressAny}}\nfunction storeTolkAddressAny(a: any_address, b: c.Builder): void {\n    let maybe_addr = a === 'none' ? null : a;\n    b.storeAddress(maybe_addr);\n}\n\nfunction loadTolkAddressAny(s: c.Slice): any_address {\n    let maybe_addr = s.loadAddressAny();\n    return maybe_addr === null ? 'none' : maybe_addr;\n}\n// {{/if:has_addressAny}}\n\n// {{if:has_bitsN}}\nfunction storeTolkBitsN(v: c.Slice, nBits: number, b: c.Builder): void {\n    if (v.remainingBits !== nBits) { throw new Error(`expected ${nBits} bits, got ${v.remainingBits}`); }\n    if (v.remainingRefs !== 0) { throw new Error(`expected 0 refs, got ${v.remainingRefs}`); }\n    b.storeSlice(v);\n}\n\nfunction loadTolkBitsN(s: c.Slice, nBits: number): c.Slice {\n    return new c.Slice(new c.BitReader(s.loadBits(nBits)), []);\n}\n// {{/if:has_bitsN}}\n\n// {{if:has_remaining}}\nfunction storeTolkRemaining(v: RemainingBitsAndRefs, b: c.Builder): void {\n    b.storeSlice(v);\n}\n\nfunction loadTolkRemaining(s: c.Slice): RemainingBitsAndRefs {\n    let rest = s.clone();\n    s.loadBits(s.remainingBits);\n    while (s.remainingRefs) {\n        s.loadRef();\n    }\n    return rest;\n}\n// {{/if:has_remaining}}\n\nfunction storeTolkNullable<T>(v: T | null, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    if (v === null) {\n        b.storeUint(0, 1);\n    } else {\n        b.storeUint(1, 1);\n        storeFn_T(v, b);\n    }\n}\n\n// {{if:has_arrayOf}}\nfunction storeArrayOf<T>(v: array<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    // the compiler stores array<T> in chunks; in TypeScript, for simplicity, store \"1 elem = 1 ref\"\n    let tail = null as c.Cell | null;\n    for (let i = 0; i < v.length; ++i) {\n        let chunkB = beginCell().storeMaybeRef(tail);\n        storeFn_T(v[v.length - 1 - i], chunkB);\n        tail = chunkB.endCell();\n    }\n    b.storeUint(v.length, 8);\n    b.storeMaybeRef(tail);\n}\n\nfunction loadArrayOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): array<T> {\n    let len = s.loadUint(8);\n    let head = s.loadMaybeRef();\n    let outArr = [] as array<T>;\n    while (head != null) {\n        let s = head.beginParse();\n        head = s.loadMaybeRef();\n        while (s.remainingBits || s.remainingRefs) {\n            outArr.push(loadFn_T(s));\n        }\n    }\n    if (len !== outArr.length) {\n        throw new Error(`mismatch array binary data: expected ${len} elements, got ${outArr.length}`);\n    }\n    return outArr;\n}\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\nfunction storeLispListOf<T>(v: lisp_list<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let tail = c.Cell.EMPTY;\n    for (let i = 0; i < v.length; ++i) {\n        let itemB = beginCell();\n        storeFn_T(v[i], itemB);\n        tail = itemB.storeRef(tail).endCell();\n    }\n    b.storeRef(tail);\n}\n\nfunction loadLispListOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): lisp_list<T> {\n    let outArr = [] as lisp_list<T>;\n    let head = s.loadRef().beginParse();\n    while (head.remainingRefs) {\n        let tailSnaked = head.loadRef();\n        let headValue = loadFn_T(head);\n        head.endParse();    // ensure no data is present besides T\n        outArr.unshift(headValue);\n        head = tailSnaked.beginParse();\n    }\n    return outArr;\n}\n// {{/if:has_lispListOf}}\n\n// {{if:has_customDictV}}\nfunction createDictionaryValue<V>(loadFn_V: LoadCallback<V>, storeFn_V: StoreCallback<V>): c.DictionaryValue<V> {\n    return {\n        serialize(self: V, b: c.Builder) {\n            storeFn_V(self, b);\n        },\n        parse(s: c.Slice): V {\n            const value = loadFn_V(s);\n            s.endParse();\n            return value;\n        }\n    }\n}\n// {{/if:has_customDictV}}\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   parse get methods result from a TVM stack\n//\n\nclass StackReader {\n    constructor(private tuple: c.TupleItem[]) {\n    }\n\n    static fromGetMethod(expectedN: number, getMethodResult: { stack: c.TupleReader }): StackReader {\n        let tuple = [] as c.TupleItem[];\n        while (getMethodResult.stack.remaining) {\n            tuple.push(getMethodResult.stack.pop());\n        }\n        if (tuple.length !== expectedN) {\n            throw new Error(`expected ${expectedN} stack width, got ${tuple.length}`);\n        }\n        return new StackReader(tuple);\n    }\n\n    private popExpecting<ItemT>(itemType: string): ItemT {\n        const item = this.tuple.shift();\n        if (item?.type === itemType) {\n            return item as ItemT;\n        }\n        throw new Error(`not '${itemType}' on a stack`);\n    }\n\n    private popCellLike(): c.Cell {\n        const item = this.tuple.shift();\n        if (item && (item.type === 'cell' || item.type === 'slice' || item.type === 'builder')) {\n            return item.cell;\n        }\n        throw new Error(`not cell/slice on a stack`);\n    }\n\n    readBigInt(): bigint {\n        return this.popExpecting<c.TupleItemInt>('int').value;\n    }\n\n    readBoolean(): boolean {\n        return this.popExpecting<c.TupleItemInt>('int').value !== 0n;\n    }\n\n    readCell(): c.Cell {\n        return this.popCellLike();\n    }\n\n    readSlice(): c.Slice {\n        return this.popCellLike().beginParse();\n    }\n\n    // {{if:stackReadsBuilder}}\n    readBuilder(): c.Builder {\n        return beginCell().storeSlice(this.popCellLike().beginParse());\n    }\n    // {{/if:stackReadsBuilder}}\n\n    // {{if:stackReadsUnknown}}\n    readUnknown(): c.TupleItem {\n        // `unknown` from Tolk is left as a raw tuple item\n        return this.tuple.shift()!;\n    }\n    // {{/if:stackReadsUnknown}}\n\n    // {{if:stackReadsArrayOf}}\n    readArrayOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        const subReader = new StackReader(subItems);\n        // array len N => N subItems => N calls to readFn_T\n        return [...subItems].map(_ => readFn_T(subReader));\n    }\n    // {{/if:stackReadsArrayOf}}\n\n    // {{if:stackReadsLispListOf}}\n    readLispListOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        // read `[1 [2 [3 null]]]` to `[1 2 3]`\n        let pairReader: StackReader = this;\n        let outArr = [] as T[];\n        while (true) {\n            if (pairReader.tuple[0].type === 'null') {\n                pairReader.tuple.shift();\n                break;\n            }\n            let headAndTail = pairReader.popExpecting<c.Tuple>('tuple').items;\n            if (headAndTail.length !== 2) {\n                throw new Error(`malformed lisp_list, expected 2 stack width, got ${headAndTail.length}`);\n            }\n            pairReader = new StackReader(headAndTail);\n            outArr.push(readFn_T(pairReader));\n        }\n        return outArr;\n    }\n    // {{/if:stackReadsLispListOf}}\n\n    // {{if:stackReadsSnakeString}}\n    readSnakeString(): string {\n        return this.readCell().beginParse().loadStringTail();\n    }\n    // {{/if:stackReadsSnakeString}}\n\n    // {{if:stackReadsTuple}}\n    readTuple<T>(expectedN: number, readFn_T: (nestedReader: StackReader) => T): T {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        if (subItems.length !== expectedN) {\n            throw new Error(`expected ${expectedN} items in a tuple, got ${subItems.length}`);\n        }\n        return readFn_T(new StackReader(subItems));\n    }\n    // {{/if:stackReadsTuple}}\n\n    // {{if:stackReadsNullLiteral}}\n    readNullLiteral(): null {\n        this.popExpecting<c.TupleItemNull>('null');\n        return null;\n    }\n    // {{/if:stackReadsNullLiteral}}\n\n    // {{if:stackReadsNullable}}\n    readNullable<T>(readFn_T: (r: StackReader) => T): T | null {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return null;\n        }\n        return readFn_T(this);\n    }\n    // {{/if:stackReadsNullable}}\n\n    // {{if:stackReadsWideNullable}}\n    readWideNullable<T>(stackW: number, readFn_T: (r: StackReader) => T): T | null {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        if (slotTypeId.value === 0n) {\n            this.tuple = this.tuple.slice(stackW);\n            return null;\n        }\n        const valueT = readFn_T(this);\n        this.tuple.shift();\n        return valueT;\n    }\n    // {{/if:stackReadsWideNullable}}\n\n    // {{if:stackReadsUnionType}}\n    readUnionType<T>(stackW: number, infoForTypeId: Record<number, [number, string | null, (r: StackReader) => any]>): T {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        const info = infoForTypeId[Number(slotTypeId.value)];   // [stackWidth, label, readFn_T{i}]\n        if (info == null) {\n            throw new Error(`unexpected UTag=${slotTypeId.value}`);\n        }\n        const label = info[1];\n        this.tuple = this.tuple.slice(stackW - 1 - info[0]);\n        const valueT = info[2](this);\n        this.tuple.shift();\n        return label == null ? valueT : { $: label, value: valueT } as T;\n    }\n    // {{/if:stackReadsUnionType}}\n\n    // {{if:stackReadsCellRef}}\n    readCellRef<T>(loadFn_T: LoadCallback<T>): CellRef<T> {\n        return { ref: loadFn_T(this.readCell().beginParse()) };\n    }\n    // {{/if:stackReadsCellRef}}\n\n    // {{if:stackReadsMapKV}}\n    readDictionary<K extends c.DictionaryKeyTypes, V>(keySerializer: c.DictionaryKey<K>, valueSerializer: c.DictionaryValue<V>): c.Dictionary<K, V> {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return c.Dictionary.empty<K, V>(keySerializer, valueSerializer);\n        }\n        return c.Dictionary.loadDirect<K, V>(keySerializer, valueSerializer, this.readCell());\n    }\n    // {{/if:stackReadsMapKV}}\n}\n\n// {{if:has_customPackUnpack}}\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   custom packToBuilder and unpackFromSlice\n//\n\ntype CustomPackToBuilderFn<T> = (self: T, b: c.Builder) => void\ntype CustomUnpackFromSliceFn<T> = (s: c.Slice) => T\n\nlet customSerializersRegistry: Map<string, [CustomPackToBuilderFn<any> | null, CustomUnpackFromSliceFn<any> | null]> = new Map;\n\nfunction ensureCustomSerializerRegistered(typeName: string) {\n    if (!customSerializersRegistry.has(typeName)) {\n        throw new Error(`Custom packToBuilder/unpackFromSlice was not registered for type 'CONTRACT_CLASS_NAME.${typeName}'.\\n(in Tolk code, they have custom logic \\`fun ${typeName}__packToBuilder\\`)\\nSteps to fix:\\n1) in your code, create and implement\\n > function ${typeName}__packToBuilder(self: ${typeName}, b: Builder): void { ... }\\n > function ${typeName}__unpackFromSlice(s: Slice): ${typeName} { ... }\\n2) register them in advance by calling\\n > CONTRACT_CLASS_NAME.registerCustomPackUnpack('${typeName}', ${typeName}__packToBuilder, ${typeName}__unpackFromSlice);`);\n    }\n}\n\nfunction invokeCustomPackToBuilder<T>(typeName: string, self: T, b: c.Builder) {\n    ensureCustomSerializerRegistered(typeName);\n    customSerializersRegistry.get(typeName)![0]!(self, b);\n}\n\nfunction invokeCustomUnpackFromSlice<T>(typeName: string, s: c.Slice): T {\n    ensureCustomSerializerRegistered(typeName);\n    return customSerializersRegistry.get(typeName)![1]!(s);\n}\n// {{/if:has_customPackUnpack}}\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   auto-generated serializers to/from cells\n//\n\ntype coins = bigint\n\n// {{intNAliases}}\n\n// {{uintNAliases}}\n\n// {{if:has_varIntN}}\n// {{varIntNAliases}}\n// {{/if:has_varIntN}}\n\n// {{if:has_bitsN}}\n// {{sliceAliases}}\n// {{/if:has_bitsN}}\n\n// {{packUnpackSerializers}}\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//    class CONTRACT_CLASS_NAME\n//\n\ninterface ExtraSendOptions {\n    bounce?: boolean                    // default: false\n    sendMode?: SendMode                 // default: SendMode.PAY_GAS_SEPARATELY\n    extraCurrencies?: c.ExtraCurrency   // default: empty dict\n}\n\ninterface DeployedAddrOptions {\n    workchain?: number                  // default: 0 (basechain)\n    toShard?: { fixedPrefixLength: number; closeTo: c.Address }\n    overrideContractCode?: c.Cell\n}\n\nfunction calculateDeployedAddress(code: c.Cell, data: c.Cell, options: DeployedAddrOptions): c.Address {\n    const stateInitCell = beginCell().store(c.storeStateInit({\n        code,\n        data,\n        splitDepth: options.toShard?.fixedPrefixLength,\n        special: null,\n        libraries: null,\n    })).endCell();\n\n    let addrHash = stateInitCell.hash();\n    if (options.toShard) {\n        const shardDepth = options.toShard.fixedPrefixLength;\n        addrHash = beginCell()\n            .storeBits(new c.BitString(options.toShard.closeTo.hash, 0, shardDepth))\n            .storeBits(new c.BitString(stateInitCell.hash(), shardDepth, 256 - shardDepth))\n            .endCell()\n            .beginParse().loadBuffer(32);\n    }\n\n    return new c.Address(options.workchain ?? 0, addrHash);\n}\n\nexport class CONTRACT_CLASS_NAME implements c.Contract {\n    static CodeCell = c.Cell.fromBase64('{{codeBoc64}}');\n\n    static Errors = {\n        // {{errorCodes}}\n    }\n\n    readonly address: c.Address\n    readonly init?: { code: c.Cell, data: c.Cell }\n\n    private constructor(address: c.Address, init?: { code: c.Cell, data: c.Cell }) {\n        this.address = address;\n        this.init = init;\n    }\n\n    // {{if:has_customPackUnpack}}\n    static registerCustomPackUnpack<T>(\n        typeName: string,\n        packToBuilderFn: CustomPackToBuilderFn<T> | null,\n        unpackFromSliceFn: CustomUnpackFromSliceFn<T> | null,\n    ) {\n        if (customSerializersRegistry.has(typeName)) {\n            throw new Error(`Custom pack/unpack for 'CONTRACT_CLASS_NAME.${typeName}' already registered`);\n        }\n        customSerializersRegistry.set(typeName, [packToBuilderFn, unpackFromSliceFn]);\n    }\n    // {{/if:has_customPackUnpack}}\n\n    static fromAddress(address: c.Address) {\n        return new CONTRACT_CLASS_NAME(address);\n    }\n\n    // {{fromStorageMethod}}\n\n    // {{createCellsMethods}}\n\n    // {{if:has_sendDeploy}}\n    async sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions) {\n        return provider.internal(via, {\n            value: msgValue,\n            body: c.Cell.EMPTY,\n            ...extraOptions\n        });\n    }\n    // {{/if:has_sendDeploy}}\n\n    // {{sendMethods}}\n\n    // {{getMethods}}\n}\n";
+export declare const OUT_TEMPLATE = "// AUTO-GENERATED, do not edit\n// It's a TypeScript wrapper for a CONTRACT_CLASS_NAME contract in Tolk.\n// Disable tsc with strict mode, it may trigger on unused aliases like `int256`.\n// @ts-nocheck\n/* eslint-disable */\n\nimport * as c from '@ton/core';\nimport { beginCell, ContractProvider, Sender, SendMode } from '@ton/core';\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   predefined types and functions\n//\n\n// {{if:has_remaining}}\ntype RemainingBitsAndRefs = c.Slice\n// {{/if:has_remaining}}\n\n// {{if:has_addressAny}}\nexport type any_address = c.Address | c.ExternalAddress | 'none'\n// {{/if:has_addressAny}}\n\n// {{if:has_arrayOf}}\ntype array<T> = T[]\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\n// TypeScript wrappers flatten a TVM linked list `[1 [2 [3 null]]]` to `[1 2 3]`\ntype lisp_list<T> = T[]\n// {{/if:has_lispListOf}}\n\ntype StoreCallback<T> = (obj: T, b: c.Builder) => void\ntype LoadCallback<T> = (s: c.Slice) => T\n\nexport type CellRef<T> = {\n    ref: T\n}\n\nfunction makeCellFrom<T>(self: T, storeFn_T: StoreCallback<T>): c.Cell {\n    let b = beginCell();\n    storeFn_T(self, b);\n    return b.endCell();\n}\n\nfunction loadAndCheckPrefix32(s: c.Slice, expected: number, structName: string): void {\n    let prefix = s.loadUint(32);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected 0x${expected.toString(16).padStart(8, '0')}, got 0x${prefix.toString(16).padStart(8, '0')}`);\n    }\n}\n\n// {{if:has_non32Prefixes}}\nfunction formatPrefix(prefixNum: number, prefixLen: number): string {\n    return prefixLen % 4 ? `0b${prefixNum.toString(2).padStart(prefixLen, '0')}` : `0x${prefixNum.toString(16).padStart(prefixLen / 4, '0')}`;\n}\n\nfunction loadAndCheckPrefix(s: c.Slice, expected: number, prefixLen: number, structName: string): void {\n    let prefix = s.loadUint(prefixLen);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected ${formatPrefix(expected, prefixLen)}, got ${formatPrefix(prefix, prefixLen)}`);\n    }\n}\n// {{/if:has_non32Prefixes}}\n\nfunction lookupPrefix(s: c.Slice, expected: number, prefixLen: number): boolean {\n    return s.remainingBits >= prefixLen && s.preloadUint(prefixLen) === expected;\n}\n\n// {{if:has_implicitUnionPrefix}}\nfunction lookupPrefixAndEat(s: c.Slice, expected: number, prefixLen: number): boolean {\n    if (lookupPrefix(s, expected, prefixLen)) {\n        s.skip(prefixLen);\n        return true;\n    }\n    return false;\n}\n// {{/if:has_implicitUnionPrefix}}\n\nfunction throwNonePrefixMatch(fieldPath: string): never {\n    throw new Error(`Incorrect prefix for '${fieldPath}': none of variants matched`);\n}\n\nfunction storeCellRef<T>(cell: CellRef<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let b_ref = c.beginCell();\n    storeFn_T(cell.ref, b_ref);\n    b.storeRef(b_ref.endCell());\n}\n\nfunction loadCellRef<T>(s: c.Slice, loadFn_T: LoadCallback<T>): CellRef<T> {\n    let s_ref = s.loadRef().beginParse();\n    return { ref: loadFn_T(s_ref) };\n}\n\n// {{if:has_addressAny}}\nfunction storeTolkAddressAny(a: any_address, b: c.Builder): void {\n    let maybe_addr = a === 'none' ? null : a;\n    b.storeAddress(maybe_addr);\n}\n\nfunction loadTolkAddressAny(s: c.Slice): any_address {\n    let maybe_addr = s.loadAddressAny();\n    return maybe_addr === null ? 'none' : maybe_addr;\n}\n// {{/if:has_addressAny}}\n\n// {{if:has_bitsN}}\nfunction storeTolkBitsN(v: c.Slice, nBits: number, b: c.Builder): void {\n    if (v.remainingBits !== nBits) { throw new Error(`expected ${nBits} bits, got ${v.remainingBits}`); }\n    if (v.remainingRefs !== 0) { throw new Error(`expected 0 refs, got ${v.remainingRefs}`); }\n    b.storeSlice(v);\n}\n\nfunction loadTolkBitsN(s: c.Slice, nBits: number): c.Slice {\n    return new c.Slice(new c.BitReader(s.loadBits(nBits)), []);\n}\n// {{/if:has_bitsN}}\n\n// {{if:has_remaining}}\nfunction storeTolkRemaining(v: RemainingBitsAndRefs, b: c.Builder): void {\n    b.storeSlice(v);\n}\n\nfunction loadTolkRemaining(s: c.Slice): RemainingBitsAndRefs {\n    let rest = s.clone();\n    s.loadBits(s.remainingBits);\n    while (s.remainingRefs) {\n        s.loadRef();\n    }\n    return rest;\n}\n// {{/if:has_remaining}}\n\nfunction storeTolkNullable<T>(v: T | null, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    if (v === null) {\n        b.storeUint(0, 1);\n    } else {\n        b.storeUint(1, 1);\n        storeFn_T(v, b);\n    }\n}\n\n// {{if:has_arrayOf}}\nfunction storeArrayOf<T>(v: array<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    // the compiler stores array<T> in chunks; in TypeScript, for simplicity, store \"1 elem = 1 ref\"\n    let tail = null as c.Cell | null;\n    for (let i = 0; i < v.length; ++i) {\n        let chunkB = beginCell().storeMaybeRef(tail);\n        storeFn_T(v[v.length - 1 - i], chunkB);\n        tail = chunkB.endCell();\n    }\n    b.storeUint(v.length, 8);\n    b.storeMaybeRef(tail);\n}\n\nfunction loadArrayOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): array<T> {\n    let len = s.loadUint(8);\n    let head = s.loadMaybeRef();\n    let outArr = [] as array<T>;\n    while (head != null) {\n        let s = head.beginParse();\n        head = s.loadMaybeRef();\n        while (s.remainingBits || s.remainingRefs) {\n            outArr.push(loadFn_T(s));\n        }\n    }\n    if (len !== outArr.length) {\n        throw new Error(`mismatch array binary data: expected ${len} elements, got ${outArr.length}`);\n    }\n    return outArr;\n}\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\nfunction storeLispListOf<T>(v: lisp_list<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let tail = c.Cell.EMPTY;\n    for (let i = 0; i < v.length; ++i) {\n        let itemB = beginCell();\n        storeFn_T(v[i], itemB);\n        tail = itemB.storeRef(tail).endCell();\n    }\n    b.storeRef(tail);\n}\n\nfunction loadLispListOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): lisp_list<T> {\n    let outArr = [] as lisp_list<T>;\n    let head = s.loadRef().beginParse();\n    while (head.remainingRefs) {\n        let tailSnaked = head.loadRef();\n        let headValue = loadFn_T(head);\n        head.endParse();    // ensure no data is present besides T\n        outArr.unshift(headValue);\n        head = tailSnaked.beginParse();\n    }\n    return outArr;\n}\n// {{/if:has_lispListOf}}\n\n// {{if:has_customDictV}}\nfunction createDictionaryValue<V>(loadFn_V: LoadCallback<V>, storeFn_V: StoreCallback<V>): c.DictionaryValue<V> {\n    return {\n        serialize(self: V, b: c.Builder) {\n            storeFn_V(self, b);\n        },\n        parse(s: c.Slice): V {\n            const value = loadFn_V(s);\n            s.endParse();\n            return value;\n        }\n    }\n}\n// {{/if:has_customDictV}}\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   parse get methods result from a TVM stack\n//\n\nclass StackReader {\n    constructor(private tuple: c.TupleItem[]) {\n    }\n\n    static fromGetMethod(expectedN: number, getMethodResult: { stack: c.TupleReader }): StackReader {\n        let tuple = [] as c.TupleItem[];\n        while (getMethodResult.stack.remaining) {\n            tuple.push(getMethodResult.stack.pop());\n        }\n        if (tuple.length !== expectedN) {\n            throw new Error(`expected ${expectedN} stack width, got ${tuple.length}`);\n        }\n        return new StackReader(tuple);\n    }\n\n    private popExpecting<ItemT>(itemType: string): ItemT {\n        const item = this.tuple.shift();\n        if (item?.type === itemType) {\n            return item as ItemT;\n        }\n        throw new Error(`not '${itemType}' on a stack`);\n    }\n\n    private popCellLike(): c.Cell {\n        const item = this.tuple.shift();\n        if (item && (item.type === 'cell' || item.type === 'slice' || item.type === 'builder')) {\n            return item.cell;\n        }\n        throw new Error(`not cell/slice on a stack`);\n    }\n\n    readBigInt(): bigint {\n        return this.popExpecting<c.TupleItemInt>('int').value;\n    }\n\n    readBoolean(): boolean {\n        return this.popExpecting<c.TupleItemInt>('int').value !== 0n;\n    }\n\n    readCell(): c.Cell {\n        return this.popCellLike();\n    }\n\n    readSlice(): c.Slice {\n        return this.popCellLike().beginParse();\n    }\n\n    // {{if:stackReadsBuilder}}\n    readBuilder(): c.Builder {\n        return beginCell().storeSlice(this.popCellLike().beginParse());\n    }\n    // {{/if:stackReadsBuilder}}\n\n    // {{if:stackReadsUnknown}}\n    readUnknown(): c.TupleItem {\n        // `unknown` from Tolk is left as a raw tuple item\n        return this.tuple.shift()!;\n    }\n    // {{/if:stackReadsUnknown}}\n\n    // {{if:stackReadsArrayOf}}\n    readArrayOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        const subReader = new StackReader(subItems);\n        // array len N => N subItems => N calls to readFn_T\n        return [...subItems].map(_ => readFn_T(subReader));\n    }\n    // {{/if:stackReadsArrayOf}}\n\n    // {{if:stackReadsLispListOf}}\n    readLispListOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        // read `[1 [2 [3 null]]]` to `[1 2 3]`\n        let pairReader: StackReader = this;\n        let outArr = [] as T[];\n        while (true) {\n            if (pairReader.tuple[0].type === 'null') {\n                pairReader.tuple.shift();\n                break;\n            }\n            let headAndTail = pairReader.popExpecting<c.Tuple>('tuple').items;\n            if (headAndTail.length !== 2) {\n                throw new Error(`malformed lisp_list, expected 2 stack width, got ${headAndTail.length}`);\n            }\n            pairReader = new StackReader(headAndTail);\n            outArr.push(readFn_T(pairReader));\n        }\n        return outArr;\n    }\n    // {{/if:stackReadsLispListOf}}\n\n    // {{if:stackReadsSnakeString}}\n    readSnakeString(): string {\n        return this.readCell().beginParse().loadStringTail();\n    }\n    // {{/if:stackReadsSnakeString}}\n\n    // {{if:stackReadsTuple}}\n    readTuple<T>(expectedN: number, readFn_T: (nestedReader: StackReader) => T): T {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        if (subItems.length !== expectedN) {\n            throw new Error(`expected ${expectedN} items in a tuple, got ${subItems.length}`);\n        }\n        return readFn_T(new StackReader(subItems));\n    }\n    // {{/if:stackReadsTuple}}\n\n    // {{if:stackReadsNullLiteral}}\n    readNullLiteral(): null {\n        this.popExpecting<c.TupleItemNull>('null');\n        return null;\n    }\n    // {{/if:stackReadsNullLiteral}}\n\n    // {{if:stackReadsNullable}}\n    readNullable<T>(readFn_T: (r: StackReader) => T): T | null {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return null;\n        }\n        return readFn_T(this);\n    }\n    // {{/if:stackReadsNullable}}\n\n    // {{if:stackReadsWideNullable}}\n    readWideNullable<T>(stackW: number, readFn_T: (r: StackReader) => T): T | null {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        if (slotTypeId.value === 0n) {\n            this.tuple = this.tuple.slice(stackW);\n            return null;\n        }\n        const valueT = readFn_T(this);\n        this.tuple.shift();\n        return valueT;\n    }\n    // {{/if:stackReadsWideNullable}}\n\n    // {{if:stackReadsUnionType}}\n    readUnionType<T>(stackW: number, infoForTypeId: Record<number, [number, string | null, (r: StackReader) => any]>): T {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        const info = infoForTypeId[Number(slotTypeId.value)];   // [stackWidth, label, readFn_T{i}]\n        if (info == null) {\n            throw new Error(`unexpected UTag=${slotTypeId.value}`);\n        }\n        const label = info[1];\n        this.tuple = this.tuple.slice(stackW - 1 - info[0]);\n        const valueT = info[2](this);\n        this.tuple.shift();\n        return label == null ? valueT : { $: label, value: valueT } as T;\n    }\n    // {{/if:stackReadsUnionType}}\n\n    // {{if:stackReadsCellRef}}\n    readCellRef<T>(loadFn_T: LoadCallback<T>): CellRef<T> {\n        return { ref: loadFn_T(this.readCell().beginParse()) };\n    }\n    // {{/if:stackReadsCellRef}}\n\n    // {{if:stackReadsMapKV}}\n    readDictionary<K extends c.DictionaryKeyTypes, V>(keySerializer: c.DictionaryKey<K>, valueSerializer: c.DictionaryValue<V>): c.Dictionary<K, V> {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return c.Dictionary.empty<K, V>(keySerializer, valueSerializer);\n        }\n        return c.Dictionary.loadDirect<K, V>(keySerializer, valueSerializer, this.readCell());\n    }\n    // {{/if:stackReadsMapKV}}\n}\n\n// {{if:has_customPackUnpack}}\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   custom packToBuilder and unpackFromSlice\n//\n\ntype CustomPackToBuilderFn<T> = (self: T, b: c.Builder) => void\ntype CustomUnpackFromSliceFn<T> = (s: c.Slice) => T\n\nlet customSerializersRegistry: Map<string, [CustomPackToBuilderFn<any> | null, CustomUnpackFromSliceFn<any> | null]> = new Map;\n\nfunction ensureCustomSerializerRegistered(typeName: string) {\n    if (!customSerializersRegistry.has(typeName)) {\n        throw new Error(`Custom packToBuilder/unpackFromSlice was not registered for type 'CONTRACT_CLASS_NAME.${typeName}'.\\n(in Tolk code, they have custom logic \\`fun ${typeName}__packToBuilder\\`)\\nSteps to fix:\\n1) in your code, create and implement\\n > function ${typeName}__packToBuilder(self: ${typeName}, b: Builder): void { ... }\\n > function ${typeName}__unpackFromSlice(s: Slice): ${typeName} { ... }\\n2) register them in advance by calling\\n > CONTRACT_CLASS_NAME.registerCustomPackUnpack('${typeName}', ${typeName}__packToBuilder, ${typeName}__unpackFromSlice);`);\n    }\n}\n\nfunction invokeCustomPackToBuilder<T>(typeName: string, self: T, b: c.Builder) {\n    ensureCustomSerializerRegistered(typeName);\n    customSerializersRegistry.get(typeName)![0]!(self, b);\n}\n\nfunction invokeCustomUnpackFromSlice<T>(typeName: string, s: c.Slice): T {\n    ensureCustomSerializerRegistered(typeName);\n    return customSerializersRegistry.get(typeName)![1]!(s);\n}\n// {{/if:has_customPackUnpack}}\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   auto-generated serializers to/from cells\n//\n\ntype coins = bigint\n\n// {{intNAliases}}\n\n// {{uintNAliases}}\n\n// {{if:has_varIntN}}\n// {{varIntNAliases}}\n// {{/if:has_varIntN}}\n\n// {{if:has_bitsN}}\n// {{sliceAliases}}\n// {{/if:has_bitsN}}\n\n// {{packUnpackSerializers}}\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//    class CONTRACT_CLASS_NAME\n//\n\ninterface ExtraSendOptions {\n    bounce?: boolean                    // default: false\n    sendMode?: SendMode                 // default: SendMode.PAY_GAS_SEPARATELY\n    extraCurrencies?: c.ExtraCurrency   // default: empty dict\n}\n\ninterface DeployedAddrOptions {\n    workchain?: number                  // default: 0 (basechain)\n    toShard?: { fixedPrefixLength: number; closeTo: c.Address }\n    overrideContractCode?: c.Cell\n}\n\nfunction calculateDeployedAddress(code: c.Cell, data: c.Cell, options: DeployedAddrOptions): c.Address {\n    const stateInitCell = beginCell().store(c.storeStateInit({\n        code,\n        data,\n        splitDepth: options.toShard?.fixedPrefixLength,\n        special: null,\n        libraries: null,\n    })).endCell();\n\n    let addrHash = stateInitCell.hash();\n    if (options.toShard) {\n        const shardDepth = options.toShard.fixedPrefixLength;\n        addrHash = beginCell()\n            .storeBits(new c.BitString(options.toShard.closeTo.hash, 0, shardDepth))\n            .storeBits(new c.BitString(stateInitCell.hash(), shardDepth, 256 - shardDepth))\n            .endCell()\n            .beginParse().loadBuffer(32);\n    }\n\n    return new c.Address(options.workchain ?? 0, addrHash);\n}\n\nexport class CONTRACT_CLASS_NAME implements c.Contract {\n    static CodeCell = c.Cell.fromBase64('{{codeBoc64}}');\n\n    static Errors = {\n        // {{errorCodes}}\n    }\n\n    readonly address: c.Address\n    readonly init?: { code: c.Cell, data: c.Cell }\n\n    protected constructor(address: c.Address, init?: { code: c.Cell, data: c.Cell }) {\n        this.address = address;\n        this.init = init;\n    }\n\n    // {{if:has_customPackUnpack}}\n    static registerCustomPackUnpack<T>(\n        typeName: string,\n        packToBuilderFn: CustomPackToBuilderFn<T> | null,\n        unpackFromSliceFn: CustomUnpackFromSliceFn<T> | null,\n    ) {\n        if (customSerializersRegistry.has(typeName)) {\n            throw new Error(`Custom pack/unpack for 'CONTRACT_CLASS_NAME.${typeName}' already registered`);\n        }\n        customSerializersRegistry.set(typeName, [packToBuilderFn, unpackFromSliceFn]);\n    }\n    // {{/if:has_customPackUnpack}}\n\n    static fromAddress(address: c.Address) {\n        return new CONTRACT_CLASS_NAME(address);\n    }\n\n    // {{fromStorageMethod}}\n\n    // {{createCellsMethods}}\n\n    // {{if:has_sendDeploy}}\n    async sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions) {\n        return provider.internal(via, {\n            value: msgValue,\n            body: c.Cell.EMPTY,\n            ...extraOptions\n        });\n    }\n    // {{/if:has_sendDeploy}}\n\n    // {{sendMethods}}\n\n    // {{getMethods}}\n}\n";

package/dist/out-template.generated.js

@@ -3,4 +3,4 @@
 // Source of truth: src/out-template.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OUT_TEMPLATE = void 0;
-exports.OUT_TEMPLATE = "// AUTO-GENERATED, do not edit\n// it's a TypeScript wrapper for a CONTRACT_CLASS_NAME contract in Tolk\n/* eslint-disable */\n\nimport * as c from '@ton/core';\nimport { beginCell, ContractProvider, Sender, SendMode } from '@ton/core';\n\n// ————————————————————————————————————————————\n//   predefined types and functions\n//\n\n// {{if:has_remaining}}\ntype RemainingBitsAndRefs = c.Slice\n// {{/if:has_remaining}}\n\n// {{if:has_addressAny}}\nexport type any_address = c.Address | c.ExternalAddress | 'none'\n// {{/if:has_addressAny}}\n\n// {{if:has_arrayOf}}\ntype array<T> = T[]\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\n// TypeScript wrappers flatten a TVM linked list `[1 [2 [3 null]]]` to `[1 2 3]`\ntype lisp_list<T> = T[]\n// {{/if:has_lispListOf}}\n\ntype StoreCallback<T> = (obj: T, b: c.Builder) => void\ntype LoadCallback<T> = (s: c.Slice) => T\n\nexport type CellRef<T> = {\n    ref: T\n}\n\nfunction makeCellFrom<T>(self: T, storeFn_T: StoreCallback<T>): c.Cell {\n    let b = beginCell();\n    storeFn_T(self, b);\n    return b.endCell();\n}\n\nfunction loadAndCheckPrefix32(s: c.Slice, expected: number, structName: string): void {\n    let prefix = s.loadUint(32);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected 0x${expected.toString(16).padStart(8, '0')}, got 0x${prefix.toString(16).padStart(8, '0')}`);\n    }\n}\n\n// {{if:has_non32Prefixes}}\nfunction formatPrefix(prefixNum: number, prefixLen: number): string {\n    return prefixLen % 4 ? `0b${prefixNum.toString(2).padStart(prefixLen, '0')}` : `0x${prefixNum.toString(16).padStart(prefixLen / 4, '0')}`;\n}\n\nfunction loadAndCheckPrefix(s: c.Slice, expected: number, prefixLen: number, structName: string): void {\n    let prefix = s.loadUint(prefixLen);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected ${formatPrefix(expected, prefixLen)}, got ${formatPrefix(prefix, prefixLen)}`);\n    }\n}\n// {{/if:has_non32Prefixes}}\n\nfunction lookupPrefix(s: c.Slice, expected: number, prefixLen: number): boolean {\n    return s.remainingBits >= prefixLen && s.preloadUint(prefixLen) === expected;\n}\n\n// {{if:has_implicitUnionPrefix}}\nfunction lookupPrefixAndEat(s: c.Slice, expected: number, prefixLen: number): boolean {\n    if (lookupPrefix(s, expected, prefixLen)) {\n        s.skip(prefixLen);\n        return true;\n    }\n    return false;\n}\n// {{/if:has_implicitUnionPrefix}}\n\nfunction throwNonePrefixMatch(fieldPath: string): never {\n    throw new Error(`Incorrect prefix for '${fieldPath}': none of variants matched`);\n}\n\nfunction storeCellRef<T>(cell: CellRef<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let b_ref = c.beginCell();\n    storeFn_T(cell.ref, b_ref);\n    b.storeRef(b_ref.endCell());\n}\n\nfunction loadCellRef<T>(s: c.Slice, loadFn_T: LoadCallback<T>): CellRef<T> {\n    let s_ref = s.loadRef().beginParse();\n    return { ref: loadFn_T(s_ref) };\n}\n\n// {{if:has_addressAny}}\nfunction storeTolkAddressAny(a: any_address, b: c.Builder): void {\n    let maybe_addr = a === 'none' ? null : a;\n    b.storeAddress(maybe_addr);\n}\n\nfunction loadTolkAddressAny(s: c.Slice): any_address {\n    let maybe_addr = s.loadAddressAny();\n    return maybe_addr === null ? 'none' : maybe_addr;\n}\n// {{/if:has_addressAny}}\n\n// {{if:has_bitsN}}\nfunction storeTolkBitsN(v: c.Slice, nBits: number, b: c.Builder): void {\n    if (v.remainingBits !== nBits) { throw new Error(`expected ${nBits} bits, got ${v.remainingBits}`); }\n    if (v.remainingRefs !== 0) { throw new Error(`expected 0 refs, got ${v.remainingRefs}`); }\n    b.storeSlice(v);\n}\n\nfunction loadTolkBitsN(s: c.Slice, nBits: number): c.Slice {\n    return new c.Slice(new c.BitReader(s.loadBits(nBits)), []);\n}\n// {{/if:has_bitsN}}\n\n// {{if:has_remaining}}\nfunction storeTolkRemaining(v: RemainingBitsAndRefs, b: c.Builder): void {\n    b.storeSlice(v);\n}\n\nfunction loadTolkRemaining(s: c.Slice): RemainingBitsAndRefs {\n    let rest = s.clone();\n    s.loadBits(s.remainingBits);\n    while (s.remainingRefs) {\n        s.loadRef();\n    }\n    return rest;\n}\n// {{/if:has_remaining}}\n\nfunction storeTolkNullable<T>(v: T | null, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    if (v === null) {\n        b.storeUint(0, 1);\n    } else {\n        b.storeUint(1, 1);\n        storeFn_T(v, b);\n    }\n}\n\n// {{if:has_arrayOf}}\nfunction storeArrayOf<T>(v: array<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    // the compiler stores array<T> in chunks; in TypeScript, for simplicity, store \"1 elem = 1 ref\"\n    let tail = null as c.Cell | null;\n    for (let i = 0; i < v.length; ++i) {\n        let chunkB = beginCell().storeMaybeRef(tail);\n        storeFn_T(v[v.length - 1 - i], chunkB);\n        tail = chunkB.endCell();\n    }\n    b.storeUint(v.length, 8);\n    b.storeMaybeRef(tail);\n}\n\nfunction loadArrayOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): array<T> {\n    let len = s.loadUint(8);\n    let head = s.loadMaybeRef();\n    let outArr = [] as array<T>;\n    while (head != null) {\n        let s = head.beginParse();\n        head = s.loadMaybeRef();\n        while (s.remainingBits || s.remainingRefs) {\n            outArr.push(loadFn_T(s));\n        }\n    }\n    if (len !== outArr.length) {\n        throw new Error(`mismatch array binary data: expected ${len} elements, got ${outArr.length}`);\n    }\n    return outArr;\n}\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\nfunction storeLispListOf<T>(v: lisp_list<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let tail = c.Cell.EMPTY;\n    for (let i = 0; i < v.length; ++i) {\n        let itemB = beginCell();\n        storeFn_T(v[i], itemB);\n        tail = itemB.storeRef(tail).endCell();\n    }\n    b.storeRef(tail);\n}\n\nfunction loadLispListOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): lisp_list<T> {\n    let outArr = [] as lisp_list<T>;\n    let head = s.loadRef().beginParse();\n    while (head.remainingRefs) {\n        let tailSnaked = head.loadRef();\n        let headValue = loadFn_T(head);\n        head.endParse();    // ensure no data is present besides T\n        outArr.unshift(headValue);\n        head = tailSnaked.beginParse();\n    }\n    return outArr;\n}\n// {{/if:has_lispListOf}}\n\n// {{if:has_customDictV}}\nfunction createDictionaryValue<V>(loadFn_V: LoadCallback<V>, storeFn_V: StoreCallback<V>): c.DictionaryValue<V> {\n    return {\n        serialize(self: V, b: c.Builder) {\n            storeFn_V(self, b);\n        },\n        parse(s: c.Slice): V {\n            const value = loadFn_V(s);\n            s.endParse();\n            return value;\n        }\n    }\n}\n// {{/if:has_customDictV}}\n\n// ————————————————————————————————————————————\n//   parse get methods result from a TVM stack\n//\n\nclass StackReader {\n    constructor(private tuple: c.TupleItem[]) {\n    }\n\n    static fromGetMethod(expectedN: number, getMethodResult: { stack: c.TupleReader }): StackReader {\n        let tuple = [] as c.TupleItem[];\n        while (getMethodResult.stack.remaining) {\n            tuple.push(getMethodResult.stack.pop());\n        }\n        if (tuple.length !== expectedN) {\n            throw new Error(`expected ${expectedN} stack width, got ${tuple.length}`);\n        }\n        return new StackReader(tuple);\n    }\n\n    private popExpecting<ItemT>(itemType: string): ItemT {\n        const item = this.tuple.shift();\n        if (item?.type === itemType) {\n            return item as ItemT;\n        }\n        throw new Error(`not '${itemType}' on a stack`);\n    }\n\n    private popCellLike(): c.Cell {\n        const item = this.tuple.shift();\n        if (item && (item.type === 'cell' || item.type === 'slice' || item.type === 'builder')) {\n            return item.cell;\n        }\n        throw new Error(`not cell/slice on a stack`);\n    }\n\n    readBigInt(): bigint {\n        return this.popExpecting<c.TupleItemInt>('int').value;\n    }\n\n    readBoolean(): boolean {\n        return this.popExpecting<c.TupleItemInt>('int').value !== 0n;\n    }\n\n    readCell(): c.Cell {\n        return this.popCellLike();\n    }\n\n    readSlice(): c.Slice {\n        return this.popCellLike().beginParse();\n    }\n\n    // {{if:stackReadsBuilder}}\n    readBuilder(): c.Builder {\n        return beginCell().storeSlice(this.popCellLike().beginParse());\n    }\n    // {{/if:stackReadsBuilder}}\n\n    // {{if:stackReadsUnknown}}\n    readUnknown(): c.TupleItem {\n        // `unknown` from Tolk is left as a raw tuple item\n        return this.tuple.shift()!;\n    }\n    // {{/if:stackReadsUnknown}}\n\n    // {{if:stackReadsArrayOf}}\n    readArrayOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        const subReader = new StackReader(subItems);\n        // array len N => N subItems => N calls to readFn_T\n        return [...subItems].map(_ => readFn_T(subReader));\n    }\n    // {{/if:stackReadsArrayOf}}\n\n    // {{if:stackReadsLispListOf}}\n    readLispListOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        // read `[1 [2 [3 null]]]` to `[1 2 3]`\n        let pairReader: StackReader = this;\n        let outArr = [] as T[];\n        while (true) {\n            if (pairReader.tuple[0].type === 'null') {\n                pairReader.tuple.shift();\n                break;\n            }\n            let headAndTail = pairReader.popExpecting<c.Tuple>('tuple').items;\n            if (headAndTail.length !== 2) {\n                throw new Error(`malformed lisp_list, expected 2 stack width, got ${headAndTail.length}`);\n            }\n            pairReader = new StackReader(headAndTail);\n            outArr.push(readFn_T(pairReader));\n        }\n        return outArr;\n    }\n    // {{/if:stackReadsLispListOf}}\n\n    // {{if:stackReadsSnakeString}}\n    readSnakeString(): string {\n        return this.readCell().beginParse().loadStringTail();\n    }\n    // {{/if:stackReadsSnakeString}}\n\n    // {{if:stackReadsTuple}}\n    readTuple<T>(expectedN: number, readFn_T: (nestedReader: StackReader) => T): T {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        if (subItems.length !== expectedN) {\n            throw new Error(`expected ${expectedN} items in a tuple, got ${subItems.length}`);\n        }\n        return readFn_T(new StackReader(subItems));\n    }\n    // {{/if:stackReadsTuple}}\n\n    // {{if:stackReadsNullLiteral}}\n    readNullLiteral(): null {\n        this.popExpecting<c.TupleItemNull>('null');\n        return null;\n    }\n    // {{/if:stackReadsNullLiteral}}\n\n    // {{if:stackReadsNullable}}\n    readNullable<T>(readFn_T: (r: StackReader) => T): T | null {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return null;\n        }\n        return readFn_T(this);\n    }\n    // {{/if:stackReadsNullable}}\n\n    // {{if:stackReadsWideNullable}}\n    readWideNullable<T>(stackW: number, readFn_T: (r: StackReader) => T): T | null {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        if (slotTypeId.value === 0n) {\n            this.tuple = this.tuple.slice(stackW);\n            return null;\n        }\n        const valueT = readFn_T(this);\n        this.tuple.shift();\n        return valueT;\n    }\n    // {{/if:stackReadsWideNullable}}\n\n    // {{if:stackReadsUnionType}}\n    readUnionType<T>(stackW: number, infoForTypeId: Record<number, [number, string | null, (r: StackReader) => any]>): T {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        const info = infoForTypeId[Number(slotTypeId.value)];   // [stackWidth, label, readFn_T{i}]\n        if (info == null) {\n            throw new Error(`unexpected UTag=${slotTypeId.value}`);\n        }\n        const label = info[1];\n        this.tuple = this.tuple.slice(stackW - 1 - info[0]);\n        const valueT = info[2](this);\n        this.tuple.shift();\n        return label == null ? valueT : { $: label, value: valueT } as T;\n    }\n    // {{/if:stackReadsUnionType}}\n\n    // {{if:stackReadsCellRef}}\n    readCellRef<T>(loadFn_T: LoadCallback<T>): CellRef<T> {\n        return { ref: loadFn_T(this.readCell().beginParse()) };\n    }\n    // {{/if:stackReadsCellRef}}\n\n    // {{if:stackReadsMapKV}}\n    readDictionary<K extends c.DictionaryKeyTypes, V>(keySerializer: c.DictionaryKey<K>, valueSerializer: c.DictionaryValue<V>): c.Dictionary<K, V> {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return c.Dictionary.empty<K, V>(keySerializer, valueSerializer);\n        }\n        return c.Dictionary.loadDirect<K, V>(keySerializer, valueSerializer, this.readCell());\n    }\n    // {{/if:stackReadsMapKV}}\n}\n\n// {{if:has_customPackUnpack}}\n// ————————————————————————————————————————————\n//   custom packToBuilder and unpackFromSlice\n//\n\ntype CustomPackToBuilderFn<T> = (self: T, b: c.Builder) => void\ntype CustomUnpackFromSliceFn<T> = (s: c.Slice) => T\n\nlet customSerializersRegistry: Map<string, [CustomPackToBuilderFn<any> | null, CustomUnpackFromSliceFn<any> | null]> = new Map;\n\nfunction ensureCustomSerializerRegistered(typeName: string) {\n    if (!customSerializersRegistry.has(typeName)) {\n        throw new Error(`Custom packToBuilder/unpackFromSlice was not registered for type 'CONTRACT_CLASS_NAME.${typeName}'.\\n(in Tolk code, they have custom logic \\`fun ${typeName}__packToBuilder\\`)\\nSteps to fix:\\n1) in your code, create and implement\\n > function ${typeName}__packToBuilder(self: ${typeName}, b: Builder): void { ... }\\n > function ${typeName}__unpackFromSlice(s: Slice): ${typeName} { ... }\\n2) register them in advance by calling\\n > CONTRACT_CLASS_NAME.registerCustomPackUnpack('${typeName}', ${typeName}__packToBuilder, ${typeName}__unpackFromSlice);`);\n    }\n}\n\nfunction invokeCustomPackToBuilder<T>(typeName: string, self: T, b: c.Builder) {\n    ensureCustomSerializerRegistered(typeName);\n    customSerializersRegistry.get(typeName)![0]!(self, b);\n}\n\nfunction invokeCustomUnpackFromSlice<T>(typeName: string, s: c.Slice): T {\n    ensureCustomSerializerRegistered(typeName);\n    return customSerializersRegistry.get(typeName)![1]!(s);\n}\n// {{/if:has_customPackUnpack}}\n\n// ————————————————————————————————————————————\n//   auto-generated serializers to/from cells\n//\n\ntype coins = bigint\n\n// {{intNAliases}}\n\n// {{uintNAliases}}\n\n// {{if:has_varIntN}}\n// {{varIntNAliases}}\n// {{/if:has_varIntN}}\n\n// {{if:has_bitsN}}\n// {{sliceAliases}}\n// {{/if:has_bitsN}}\n\n// {{packUnpackSerializers}}\n\n// ————————————————————————————————————————————\n//    class CONTRACT_CLASS_NAME\n//\n\ninterface ExtraSendOptions {\n    bounce?: boolean                    // default: false\n    sendMode?: SendMode                 // default: SendMode.PAY_GAS_SEPARATELY\n    extraCurrencies?: c.ExtraCurrency   // default: empty dict\n}\n\ninterface DeployedAddrOptions {\n    workchain?: number                  // default: 0 (basechain)\n    toShard?: { fixedPrefixLength: number; closeTo: c.Address }\n    overrideContractCode?: c.Cell\n}\n\nfunction calculateDeployedAddress(code: c.Cell, data: c.Cell, options: DeployedAddrOptions): c.Address {\n    const stateInitCell = beginCell().store(c.storeStateInit({\n        code,\n        data,\n        splitDepth: options.toShard?.fixedPrefixLength,\n        special: null,\n        libraries: null,\n    })).endCell();\n\n    let addrHash = stateInitCell.hash();\n    if (options.toShard) {\n        const shardDepth = options.toShard.fixedPrefixLength;\n        addrHash = beginCell()\n            .storeBits(new c.BitString(options.toShard.closeTo.hash, 0, shardDepth))\n            .storeBits(new c.BitString(stateInitCell.hash(), shardDepth, 256 - shardDepth))\n            .endCell()\n            .beginParse().loadBuffer(32);\n    }\n\n    return new c.Address(options.workchain ?? 0, addrHash);\n}\n\nexport class CONTRACT_CLASS_NAME implements c.Contract {\n    static CodeCell = c.Cell.fromBase64('{{codeBoc64}}');\n\n    static Errors = {\n        // {{errorCodes}}\n    }\n\n    readonly address: c.Address\n    readonly init?: { code: c.Cell, data: c.Cell }\n\n    private constructor(address: c.Address, init?: { code: c.Cell, data: c.Cell }) {\n        this.address = address;\n        this.init = init;\n    }\n\n    // {{if:has_customPackUnpack}}\n    static registerCustomPackUnpack<T>(\n        typeName: string,\n        packToBuilderFn: CustomPackToBuilderFn<T> | null,\n        unpackFromSliceFn: CustomUnpackFromSliceFn<T> | null,\n    ) {\n        if (customSerializersRegistry.has(typeName)) {\n            throw new Error(`Custom pack/unpack for 'CONTRACT_CLASS_NAME.${typeName}' already registered`);\n        }\n        customSerializersRegistry.set(typeName, [packToBuilderFn, unpackFromSliceFn]);\n    }\n    // {{/if:has_customPackUnpack}}\n\n    static fromAddress(address: c.Address) {\n        return new CONTRACT_CLASS_NAME(address);\n    }\n\n    // {{fromStorageMethod}}\n\n    // {{createCellsMethods}}\n\n    // {{if:has_sendDeploy}}\n    async sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions) {\n        return provider.internal(via, {\n            value: msgValue,\n            body: c.Cell.EMPTY,\n            ...extraOptions\n        });\n    }\n    // {{/if:has_sendDeploy}}\n\n    // {{sendMethods}}\n\n    // {{getMethods}}\n}\n";
+exports.OUT_TEMPLATE = "// AUTO-GENERATED, do not edit\n// It's a TypeScript wrapper for a CONTRACT_CLASS_NAME contract in Tolk.\n// Disable tsc with strict mode, it may trigger on unused aliases like `int256`.\n// @ts-nocheck\n/* eslint-disable */\n\nimport * as c from '@ton/core';\nimport { beginCell, ContractProvider, Sender, SendMode } from '@ton/core';\n\n// ————————————————————————————————————————————\n//   predefined types and functions\n//\n\n// {{if:has_remaining}}\ntype RemainingBitsAndRefs = c.Slice\n// {{/if:has_remaining}}\n\n// {{if:has_addressAny}}\nexport type any_address = c.Address | c.ExternalAddress | 'none'\n// {{/if:has_addressAny}}\n\n// {{if:has_arrayOf}}\ntype array<T> = T[]\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\n// TypeScript wrappers flatten a TVM linked list `[1 [2 [3 null]]]` to `[1 2 3]`\ntype lisp_list<T> = T[]\n// {{/if:has_lispListOf}}\n\ntype StoreCallback<T> = (obj: T, b: c.Builder) => void\ntype LoadCallback<T> = (s: c.Slice) => T\n\nexport type CellRef<T> = {\n    ref: T\n}\n\nfunction makeCellFrom<T>(self: T, storeFn_T: StoreCallback<T>): c.Cell {\n    let b = beginCell();\n    storeFn_T(self, b);\n    return b.endCell();\n}\n\nfunction loadAndCheckPrefix32(s: c.Slice, expected: number, structName: string): void {\n    let prefix = s.loadUint(32);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected 0x${expected.toString(16).padStart(8, '0')}, got 0x${prefix.toString(16).padStart(8, '0')}`);\n    }\n}\n\n// {{if:has_non32Prefixes}}\nfunction formatPrefix(prefixNum: number, prefixLen: number): string {\n    return prefixLen % 4 ? `0b${prefixNum.toString(2).padStart(prefixLen, '0')}` : `0x${prefixNum.toString(16).padStart(prefixLen / 4, '0')}`;\n}\n\nfunction loadAndCheckPrefix(s: c.Slice, expected: number, prefixLen: number, structName: string): void {\n    let prefix = s.loadUint(prefixLen);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected ${formatPrefix(expected, prefixLen)}, got ${formatPrefix(prefix, prefixLen)}`);\n    }\n}\n// {{/if:has_non32Prefixes}}\n\nfunction lookupPrefix(s: c.Slice, expected: number, prefixLen: number): boolean {\n    return s.remainingBits >= prefixLen && s.preloadUint(prefixLen) === expected;\n}\n\n// {{if:has_implicitUnionPrefix}}\nfunction lookupPrefixAndEat(s: c.Slice, expected: number, prefixLen: number): boolean {\n    if (lookupPrefix(s, expected, prefixLen)) {\n        s.skip(prefixLen);\n        return true;\n    }\n    return false;\n}\n// {{/if:has_implicitUnionPrefix}}\n\nfunction throwNonePrefixMatch(fieldPath: string): never {\n    throw new Error(`Incorrect prefix for '${fieldPath}': none of variants matched`);\n}\n\nfunction storeCellRef<T>(cell: CellRef<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let b_ref = c.beginCell();\n    storeFn_T(cell.ref, b_ref);\n    b.storeRef(b_ref.endCell());\n}\n\nfunction loadCellRef<T>(s: c.Slice, loadFn_T: LoadCallback<T>): CellRef<T> {\n    let s_ref = s.loadRef().beginParse();\n    return { ref: loadFn_T(s_ref) };\n}\n\n// {{if:has_addressAny}}\nfunction storeTolkAddressAny(a: any_address, b: c.Builder): void {\n    let maybe_addr = a === 'none' ? null : a;\n    b.storeAddress(maybe_addr);\n}\n\nfunction loadTolkAddressAny(s: c.Slice): any_address {\n    let maybe_addr = s.loadAddressAny();\n    return maybe_addr === null ? 'none' : maybe_addr;\n}\n// {{/if:has_addressAny}}\n\n// {{if:has_bitsN}}\nfunction storeTolkBitsN(v: c.Slice, nBits: number, b: c.Builder): void {\n    if (v.remainingBits !== nBits) { throw new Error(`expected ${nBits} bits, got ${v.remainingBits}`); }\n    if (v.remainingRefs !== 0) { throw new Error(`expected 0 refs, got ${v.remainingRefs}`); }\n    b.storeSlice(v);\n}\n\nfunction loadTolkBitsN(s: c.Slice, nBits: number): c.Slice {\n    return new c.Slice(new c.BitReader(s.loadBits(nBits)), []);\n}\n// {{/if:has_bitsN}}\n\n// {{if:has_remaining}}\nfunction storeTolkRemaining(v: RemainingBitsAndRefs, b: c.Builder): void {\n    b.storeSlice(v);\n}\n\nfunction loadTolkRemaining(s: c.Slice): RemainingBitsAndRefs {\n    let rest = s.clone();\n    s.loadBits(s.remainingBits);\n    while (s.remainingRefs) {\n        s.loadRef();\n    }\n    return rest;\n}\n// {{/if:has_remaining}}\n\nfunction storeTolkNullable<T>(v: T | null, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    if (v === null) {\n        b.storeUint(0, 1);\n    } else {\n        b.storeUint(1, 1);\n        storeFn_T(v, b);\n    }\n}\n\n// {{if:has_arrayOf}}\nfunction storeArrayOf<T>(v: array<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    // the compiler stores array<T> in chunks; in TypeScript, for simplicity, store \"1 elem = 1 ref\"\n    let tail = null as c.Cell | null;\n    for (let i = 0; i < v.length; ++i) {\n        let chunkB = beginCell().storeMaybeRef(tail);\n        storeFn_T(v[v.length - 1 - i], chunkB);\n        tail = chunkB.endCell();\n    }\n    b.storeUint(v.length, 8);\n    b.storeMaybeRef(tail);\n}\n\nfunction loadArrayOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): array<T> {\n    let len = s.loadUint(8);\n    let head = s.loadMaybeRef();\n    let outArr = [] as array<T>;\n    while (head != null) {\n        let s = head.beginParse();\n        head = s.loadMaybeRef();\n        while (s.remainingBits || s.remainingRefs) {\n            outArr.push(loadFn_T(s));\n        }\n    }\n    if (len !== outArr.length) {\n        throw new Error(`mismatch array binary data: expected ${len} elements, got ${outArr.length}`);\n    }\n    return outArr;\n}\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\nfunction storeLispListOf<T>(v: lisp_list<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let tail = c.Cell.EMPTY;\n    for (let i = 0; i < v.length; ++i) {\n        let itemB = beginCell();\n        storeFn_T(v[i], itemB);\n        tail = itemB.storeRef(tail).endCell();\n    }\n    b.storeRef(tail);\n}\n\nfunction loadLispListOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): lisp_list<T> {\n    let outArr = [] as lisp_list<T>;\n    let head = s.loadRef().beginParse();\n    while (head.remainingRefs) {\n        let tailSnaked = head.loadRef();\n        let headValue = loadFn_T(head);\n        head.endParse();    // ensure no data is present besides T\n        outArr.unshift(headValue);\n        head = tailSnaked.beginParse();\n    }\n    return outArr;\n}\n// {{/if:has_lispListOf}}\n\n// {{if:has_customDictV}}\nfunction createDictionaryValue<V>(loadFn_V: LoadCallback<V>, storeFn_V: StoreCallback<V>): c.DictionaryValue<V> {\n    return {\n        serialize(self: V, b: c.Builder) {\n            storeFn_V(self, b);\n        },\n        parse(s: c.Slice): V {\n            const value = loadFn_V(s);\n            s.endParse();\n            return value;\n        }\n    }\n}\n// {{/if:has_customDictV}}\n\n// ————————————————————————————————————————————\n//   parse get methods result from a TVM stack\n//\n\nclass StackReader {\n    constructor(private tuple: c.TupleItem[]) {\n    }\n\n    static fromGetMethod(expectedN: number, getMethodResult: { stack: c.TupleReader }): StackReader {\n        let tuple = [] as c.TupleItem[];\n        while (getMethodResult.stack.remaining) {\n            tuple.push(getMethodResult.stack.pop());\n        }\n        if (tuple.length !== expectedN) {\n            throw new Error(`expected ${expectedN} stack width, got ${tuple.length}`);\n        }\n        return new StackReader(tuple);\n    }\n\n    private popExpecting<ItemT>(itemType: string): ItemT {\n        const item = this.tuple.shift();\n        if (item?.type === itemType) {\n            return item as ItemT;\n        }\n        throw new Error(`not '${itemType}' on a stack`);\n    }\n\n    private popCellLike(): c.Cell {\n        const item = this.tuple.shift();\n        if (item && (item.type === 'cell' || item.type === 'slice' || item.type === 'builder')) {\n            return item.cell;\n        }\n        throw new Error(`not cell/slice on a stack`);\n    }\n\n    readBigInt(): bigint {\n        return this.popExpecting<c.TupleItemInt>('int').value;\n    }\n\n    readBoolean(): boolean {\n        return this.popExpecting<c.TupleItemInt>('int').value !== 0n;\n    }\n\n    readCell(): c.Cell {\n        return this.popCellLike();\n    }\n\n    readSlice(): c.Slice {\n        return this.popCellLike().beginParse();\n    }\n\n    // {{if:stackReadsBuilder}}\n    readBuilder(): c.Builder {\n        return beginCell().storeSlice(this.popCellLike().beginParse());\n    }\n    // {{/if:stackReadsBuilder}}\n\n    // {{if:stackReadsUnknown}}\n    readUnknown(): c.TupleItem {\n        // `unknown` from Tolk is left as a raw tuple item\n        return this.tuple.shift()!;\n    }\n    // {{/if:stackReadsUnknown}}\n\n    // {{if:stackReadsArrayOf}}\n    readArrayOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        const subReader = new StackReader(subItems);\n        // array len N => N subItems => N calls to readFn_T\n        return [...subItems].map(_ => readFn_T(subReader));\n    }\n    // {{/if:stackReadsArrayOf}}\n\n    // {{if:stackReadsLispListOf}}\n    readLispListOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        // read `[1 [2 [3 null]]]` to `[1 2 3]`\n        let pairReader: StackReader = this;\n        let outArr = [] as T[];\n        while (true) {\n            if (pairReader.tuple[0].type === 'null') {\n                pairReader.tuple.shift();\n                break;\n            }\n            let headAndTail = pairReader.popExpecting<c.Tuple>('tuple').items;\n            if (headAndTail.length !== 2) {\n                throw new Error(`malformed lisp_list, expected 2 stack width, got ${headAndTail.length}`);\n            }\n            pairReader = new StackReader(headAndTail);\n            outArr.push(readFn_T(pairReader));\n        }\n        return outArr;\n    }\n    // {{/if:stackReadsLispListOf}}\n\n    // {{if:stackReadsSnakeString}}\n    readSnakeString(): string {\n        return this.readCell().beginParse().loadStringTail();\n    }\n    // {{/if:stackReadsSnakeString}}\n\n    // {{if:stackReadsTuple}}\n    readTuple<T>(expectedN: number, readFn_T: (nestedReader: StackReader) => T): T {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        if (subItems.length !== expectedN) {\n            throw new Error(`expected ${expectedN} items in a tuple, got ${subItems.length}`);\n        }\n        return readFn_T(new StackReader(subItems));\n    }\n    // {{/if:stackReadsTuple}}\n\n    // {{if:stackReadsNullLiteral}}\n    readNullLiteral(): null {\n        this.popExpecting<c.TupleItemNull>('null');\n        return null;\n    }\n    // {{/if:stackReadsNullLiteral}}\n\n    // {{if:stackReadsNullable}}\n    readNullable<T>(readFn_T: (r: StackReader) => T): T | null {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return null;\n        }\n        return readFn_T(this);\n    }\n    // {{/if:stackReadsNullable}}\n\n    // {{if:stackReadsWideNullable}}\n    readWideNullable<T>(stackW: number, readFn_T: (r: StackReader) => T): T | null {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        if (slotTypeId.value === 0n) {\n            this.tuple = this.tuple.slice(stackW);\n            return null;\n        }\n        const valueT = readFn_T(this);\n        this.tuple.shift();\n        return valueT;\n    }\n    // {{/if:stackReadsWideNullable}}\n\n    // {{if:stackReadsUnionType}}\n    readUnionType<T>(stackW: number, infoForTypeId: Record<number, [number, string | null, (r: StackReader) => any]>): T {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        const info = infoForTypeId[Number(slotTypeId.value)];   // [stackWidth, label, readFn_T{i}]\n        if (info == null) {\n            throw new Error(`unexpected UTag=${slotTypeId.value}`);\n        }\n        const label = info[1];\n        this.tuple = this.tuple.slice(stackW - 1 - info[0]);\n        const valueT = info[2](this);\n        this.tuple.shift();\n        return label == null ? valueT : { $: label, value: valueT } as T;\n    }\n    // {{/if:stackReadsUnionType}}\n\n    // {{if:stackReadsCellRef}}\n    readCellRef<T>(loadFn_T: LoadCallback<T>): CellRef<T> {\n        return { ref: loadFn_T(this.readCell().beginParse()) };\n    }\n    // {{/if:stackReadsCellRef}}\n\n    // {{if:stackReadsMapKV}}\n    readDictionary<K extends c.DictionaryKeyTypes, V>(keySerializer: c.DictionaryKey<K>, valueSerializer: c.DictionaryValue<V>): c.Dictionary<K, V> {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return c.Dictionary.empty<K, V>(keySerializer, valueSerializer);\n        }\n        return c.Dictionary.loadDirect<K, V>(keySerializer, valueSerializer, this.readCell());\n    }\n    // {{/if:stackReadsMapKV}}\n}\n\n// {{if:has_customPackUnpack}}\n// ————————————————————————————————————————————\n//   custom packToBuilder and unpackFromSlice\n//\n\ntype CustomPackToBuilderFn<T> = (self: T, b: c.Builder) => void\ntype CustomUnpackFromSliceFn<T> = (s: c.Slice) => T\n\nlet customSerializersRegistry: Map<string, [CustomPackToBuilderFn<any> | null, CustomUnpackFromSliceFn<any> | null]> = new Map;\n\nfunction ensureCustomSerializerRegistered(typeName: string) {\n    if (!customSerializersRegistry.has(typeName)) {\n        throw new Error(`Custom packToBuilder/unpackFromSlice was not registered for type 'CONTRACT_CLASS_NAME.${typeName}'.\\n(in Tolk code, they have custom logic \\`fun ${typeName}__packToBuilder\\`)\\nSteps to fix:\\n1) in your code, create and implement\\n > function ${typeName}__packToBuilder(self: ${typeName}, b: Builder): void { ... }\\n > function ${typeName}__unpackFromSlice(s: Slice): ${typeName} { ... }\\n2) register them in advance by calling\\n > CONTRACT_CLASS_NAME.registerCustomPackUnpack('${typeName}', ${typeName}__packToBuilder, ${typeName}__unpackFromSlice);`);\n    }\n}\n\nfunction invokeCustomPackToBuilder<T>(typeName: string, self: T, b: c.Builder) {\n    ensureCustomSerializerRegistered(typeName);\n    customSerializersRegistry.get(typeName)![0]!(self, b);\n}\n\nfunction invokeCustomUnpackFromSlice<T>(typeName: string, s: c.Slice): T {\n    ensureCustomSerializerRegistered(typeName);\n    return customSerializersRegistry.get(typeName)![1]!(s);\n}\n// {{/if:has_customPackUnpack}}\n\n// ————————————————————————————————————————————\n//   auto-generated serializers to/from cells\n//\n\ntype coins = bigint\n\n// {{intNAliases}}\n\n// {{uintNAliases}}\n\n// {{if:has_varIntN}}\n// {{varIntNAliases}}\n// {{/if:has_varIntN}}\n\n// {{if:has_bitsN}}\n// {{sliceAliases}}\n// {{/if:has_bitsN}}\n\n// {{packUnpackSerializers}}\n\n// ————————————————————————————————————————————\n//    class CONTRACT_CLASS_NAME\n//\n\ninterface ExtraSendOptions {\n    bounce?: boolean                    // default: false\n    sendMode?: SendMode                 // default: SendMode.PAY_GAS_SEPARATELY\n    extraCurrencies?: c.ExtraCurrency   // default: empty dict\n}\n\ninterface DeployedAddrOptions {\n    workchain?: number                  // default: 0 (basechain)\n    toShard?: { fixedPrefixLength: number; closeTo: c.Address }\n    overrideContractCode?: c.Cell\n}\n\nfunction calculateDeployedAddress(code: c.Cell, data: c.Cell, options: DeployedAddrOptions): c.Address {\n    const stateInitCell = beginCell().store(c.storeStateInit({\n        code,\n        data,\n        splitDepth: options.toShard?.fixedPrefixLength,\n        special: null,\n        libraries: null,\n    })).endCell();\n\n    let addrHash = stateInitCell.hash();\n    if (options.toShard) {\n        const shardDepth = options.toShard.fixedPrefixLength;\n        addrHash = beginCell()\n            .storeBits(new c.BitString(options.toShard.closeTo.hash, 0, shardDepth))\n            .storeBits(new c.BitString(stateInitCell.hash(), shardDepth, 256 - shardDepth))\n            .endCell()\n            .beginParse().loadBuffer(32);\n    }\n\n    return new c.Address(options.workchain ?? 0, addrHash);\n}\n\nexport class CONTRACT_CLASS_NAME implements c.Contract {\n    static CodeCell = c.Cell.fromBase64('{{codeBoc64}}');\n\n    static Errors = {\n        // {{errorCodes}}\n    }\n\n    readonly address: c.Address\n    readonly init?: { code: c.Cell, data: c.Cell }\n\n    protected constructor(address: c.Address, init?: { code: c.Cell, data: c.Cell }) {\n        this.address = address;\n        this.init = init;\n    }\n\n    // {{if:has_customPackUnpack}}\n    static registerCustomPackUnpack<T>(\n        typeName: string,\n        packToBuilderFn: CustomPackToBuilderFn<T> | null,\n        unpackFromSliceFn: CustomUnpackFromSliceFn<T> | null,\n    ) {\n        if (customSerializersRegistry.has(typeName)) {\n            throw new Error(`Custom pack/unpack for 'CONTRACT_CLASS_NAME.${typeName}' already registered`);\n        }\n        customSerializersRegistry.set(typeName, [packToBuilderFn, unpackFromSliceFn]);\n    }\n    // {{/if:has_customPackUnpack}}\n\n    static fromAddress(address: c.Address) {\n        return new CONTRACT_CLASS_NAME(address);\n    }\n\n    // {{fromStorageMethod}}\n\n    // {{createCellsMethods}}\n\n    // {{if:has_sendDeploy}}\n    async sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions) {\n        return provider.internal(via, {\n            value: msgValue,\n            body: c.Cell.EMPTY,\n            ...extraOptions\n        });\n    }\n    // {{/if:has_sendDeploy}}\n\n    // {{sendMethods}}\n\n    // {{getMethods}}\n}\n";

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.3",
   "description": "Generate TypeScript wrappers from Tolk ABI",
   "author": "TON Core",
   "license": "MIT",