gen-typescript-from-tolk-dev 0.1.0 → 0.2.1

package/dist/emit-pack-unpack.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitLoadExpr = emitLoadExpr;
+exports.emitLoadCallback = emitLoadCallback;
+exports.emitStoreStatement = emitStoreStatement;
+exports.emitStoreCallback = emitStoreCallback;
+exports.emitMakeCellFromExpr = emitMakeCellFromExpr;
+exports.emitCallToCreateMethodExpr = emitCallToCreateMethodExpr;
+exports.emitDictKVSerializers = emitDictKVSerializers;
+const codegen_ctx_1 = require("./codegen-ctx");
+const emit_ts_types_1 = require("./emit-ts-types");
+const formatting_1 = require("./formatting");
+const unsupported_errors_1 = require("./unsupported-errors");
+const types_kernel_1 = require("./types-kernel");
+// Emit a TS "load {ty} from slice `s`" expression.
+// Parameter `fieldPath` is used for error messages only: e.g. when an input opcode is incorrect,
+// the fired Error will contain struct/field name.
+function emitLoadExpr(ctx, fieldPath, ty) {
+    switch (ty.kind) {
+        case 'int':
+        case 'builder':
+        case 'slice':
+        case 'unknown':
+        case 'callable': {
+            let hint = ty.kind === 'int' ? ' (not int32/uint64/etc.)' :
+                ty.kind === 'builder' || ty.kind === 'slice' ? ' (it can be used for writing only)' :
+                    '';
+            throw new unsupported_errors_1.CantGeneratePackUnpack(`'${fieldPath}' is '${(0, types_kernel_1.renderTy)(ty)}'${hint}`);
+        }
+        case 'intN': return `s.loadIntBig(${ty.n})`;
+        case 'uintN': return `s.loadUintBig(${ty.n})`;
+        case 'varintN': return `s.loadVarIntBig(${Math.log2(ty.n)})`;
+        case 'varuintN': return `s.loadVarUintBig(${Math.log2(ty.n)})`;
+        case 'coins': return `s.loadCoins()`;
+        case 'bool': return `s.loadBoolean()`;
+        case 'cell': return `s.loadRef()`;
+        case 'string': return `s.loadStringRefTail()`;
+        case 'remaining': return `${codegen_ctx_1.RUNTIME.loadTolkRemaining}(s)`;
+        case 'address': return `s.loadAddress()`;
+        case 'addressOpt': return `s.loadMaybeAddress()`;
+        case 'addressExt': return `s.loadExternalAddress()`;
+        case 'addressAny': return `${codegen_ctx_1.RUNTIME.loadTolkAddressAny}(s)`;
+        case 'bitsN': return `${codegen_ctx_1.RUNTIME.loadTolkBitsN}(s, ${ty.n})`;
+        case 'nullLiteral': return `null`;
+        case 'void': return `void 0`;
+        case 'nullable': return `s.loadBoolean() ? ${emitLoadExpr(ctx, fieldPath, ty.inner)} : null`;
+        case 'cellOf': return `${codegen_ctx_1.RUNTIME.loadCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(s, ${emitLoadCallback(ctx, fieldPath, ty.inner)})`;
+        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.loadArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner)})`;
+        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.loadLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner)})`;
+        case 'tensor': return `[${ty.items.map((item, i) => emitLoadExpr(ctx, `${fieldPath}[${i}]`, item)).join(', ')}]`;
+        case 'shapedTuple': return `[${ty.items.map((item, i) => emitLoadExpr(ctx, `${fieldPath}[${i}]`, item)).join(', ')}]`;
+        case 'mapKV': return `c.Dictionary.load<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.k, ty.v)}>(${emitDictKVSerializers(ctx, fieldPath, ty.k, ty.v)}, s)`;
+        case 'EnumRef': return `${ty.enum_name}.fromSlice(s)`;
+        case 'StructRef': {
+            if (ty.type_args) {
+                const cb = ty.type_args.map((ta) => emitLoadCallback(ctx, fieldPath, ta)).join(', ');
+                return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.fromSlice<${ty.type_args.map((ta) => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(s, ${cb})`;
+            }
+            return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.fromSlice(s)`;
+        }
+        case 'AliasRef': {
+            if (ty.type_args) {
+                const cb = ty.type_args.map((ta) => emitLoadCallback(ctx, fieldPath, ta)).join(', ');
+                return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.fromSlice<${ty.type_args.map((ta) => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(s, ${cb})`;
+            }
+            return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.fromSlice(s)`;
+        }
+        case 'genericT': return `loadFn_${ty.name_t}(s)`;
+        case 'union': {
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
+            const isEither01 = variants.length === 2 && variants[0].prefix_str === '0b0' && variants[1].prefix_str === '0b1';
+            if (isEither01) {
+                const l = (0, emit_ts_types_1.emitUnionLabelAndValue)(variants[0], emitLoadExpr(ctx, fieldPath, variants[0].variant_ty));
+                const r = (0, emit_ts_types_1.emitUnionLabelAndValue)(variants[1], emitLoadExpr(ctx, fieldPath, variants[1].variant_ty));
+                return `s.loadBoolean() ? ${r} : ${l}`;
+            }
+            let buf = new formatting_1.OutBuf();
+            for (let v of variants) {
+                const checkFn = v.is_prefix_implicit ? codegen_ctx_1.RUNTIME.lookupPrefixAndEat : codegen_ctx_1.RUNTIME.lookupPrefix;
+                const body = (0, emit_ts_types_1.emitUnionLabelAndValue)(v, emitLoadExpr(ctx, fieldPath, v.variant_ty));
+                buf.push(`${checkFn}(s, ${v.prefix_str}, ${v.prefix_len}) ? ${body} :`);
+                if (v.is_prefix_implicit) {
+                    ctx.has_implicitUnionPrefix = true;
+                }
+                if (v.prefix_str === variants[0].prefix_str) {
+                    buf.indent();
+                }
+            }
+            buf.push(`${codegen_ctx_1.RUNTIME.throwNonePrefixMatch}('${fieldPath}')`);
+            return buf.toString();
+        }
+    }
+}
+// Emit a TS "load {ty} from slice `s`" callback (not expression).
+// Callbacks are passed for generics (user-defined generic types and built-ins),
+// e.g., `loadCellRef<T>(s, {callbackForT})`.
+// We could just emit `(s) => loadExprForT(s)`, but to produce less boilerplate, shorten common cases:
+// not `(s) => SomeStruct.fromSlice(s)` but `SomeStruct.fromSlice` as a valid callback.
+function emitLoadCallback(ctx, fieldPath, ty) {
+    if (ty.kind === 'addressAny')
+        return codegen_ctx_1.RUNTIME.loadTolkAddressAny;
+    if (ty.kind === 'remaining')
+        return codegen_ctx_1.RUNTIME.loadTolkRemaining;
+    if (ty.kind === 'EnumRef')
+        return `${ty.enum_name}.fromSlice`;
+    if (ty.kind === 'genericT')
+        return `loadFn_${ty.name_t}`;
+    if (ty.kind === 'StructRef' && !ty.type_args)
+        return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.fromSlice`;
+    if (ty.kind === 'AliasRef' && !ty.type_args)
+        return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.fromSlice`;
+    return formatting_1.OutBuf.onNewLine(`(s) => ${emitLoadExpr(ctx, fieldPath, ty)}`);
+}
+// Emit a TS "store {expr of type ty} into builder `b`" statement.
+// Parameter `tsExpr` is a valid expression: "self.field", "v" (inside a callback), and other.
+function emitStoreStatement(ctx, tsExpr, ty) {
+    switch (ty.kind) {
+        case 'int':
+        case 'unknown':
+        case 'nullLiteral':
+        case 'callable': {
+            let hint = ty.kind === 'int' ? ' (not int32/uint64/etc.)' : '';
+            throw new unsupported_errors_1.CantGeneratePackUnpack(`'${tsExpr}' is '${(0, types_kernel_1.renderTy)(ty)}'${hint}`);
+        }
+        case 'intN': return `b.storeInt(${tsExpr}, ${ty.n});`;
+        case 'uintN': return `b.storeUint(${tsExpr}, ${ty.n});`;
+        case 'varintN': return `b.storeVarInt(${tsExpr}, ${Math.log2(ty.n)});`;
+        case 'varuintN': return `b.storeVarUint(${tsExpr}, ${Math.log2(ty.n)});`;
+        case 'coins': return `b.storeCoins(${tsExpr});`;
+        case 'bool': return `b.storeBit(${tsExpr});`;
+        case 'cell': return `b.storeRef(${tsExpr});`;
+        case 'builder': return `b.storeBuilder(${tsExpr});`;
+        case 'slice': return `b.storeSlice(${tsExpr});`;
+        case 'string': return `b.storeStringRefTail(${tsExpr});`;
+        case 'remaining': return `${codegen_ctx_1.RUNTIME.storeTolkRemaining}(${tsExpr}, b);`;
+        case 'address': return `b.storeAddress(${tsExpr});`;
+        case 'addressOpt': return `b.storeAddress(${tsExpr});`;
+        case 'addressExt': return `b.storeAddress(${tsExpr});`;
+        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)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner)});`;
+        case 'cellOf': return `${codegen_ctx_1.RUNTIME.storeCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner)});`;
+        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.storeArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner)});`;
+        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.storeLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner)});`;
+        case 'tensor': return ty.items.length ? ty.items.map((_, i) => emitStoreStatement(ctx, `${tsExpr}[${i}]`, ty.items[i])).join('\n') : `{}`;
+        case 'shapedTuple': return ty.items.length ? ty.items.map((_, i) => emitStoreStatement(ctx, `${tsExpr}[${i}]`, ty.items[i])).join('\n') : `{}`;
+        case 'mapKV': return `b.storeDict<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.k, ty.v)}>(${tsExpr}, ${emitDictKVSerializers(ctx, tsExpr, ty.k, ty.v)});`;
+        case 'EnumRef': return `${ty.enum_name}.store(${tsExpr}, b);`;
+        case 'StructRef': {
+            if (ty.type_args) {
+                const cb = ty.type_args.map(ta => emitStoreCallback(ctx, ta)).join(', ');
+                return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.store<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${tsExpr}, b, ${cb});`;
+            }
+            return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.store(${tsExpr}, b);`;
+        }
+        case 'AliasRef': {
+            if (ty.type_args) {
+                const cb = ty.type_args.map(ta => emitStoreCallback(ctx, ta)).join(', ');
+                return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.store<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${tsExpr}, b, ${cb});`;
+            }
+            return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.store(${tsExpr}, b);`;
+        }
+        case 'genericT': return `storeFn_${ty.name_t}(${tsExpr}, b);`;
+        case 'union': {
+            const buf = new formatting_1.OutBuf();
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
+            const hasNull = variants.find(v => v.variant_ty.kind === 'nullLiteral');
+            if (hasNull) {
+                buf.push(`if (${tsExpr} === null) {`);
+                buf.push(`b.storeUint(${hasNull.prefix_str}, ${hasNull.prefix_len});`);
+                buf.push(`} else switch (${tsExpr}.$) {`);
+            }
+            else {
+                buf.push(`switch (${tsExpr}.$) {`);
+            }
+            for (let v of variants) {
+                if (v.variant_ty.kind === 'nullLiteral')
+                    continue;
+                buf.push(`case '${v.labelStr}':`).indent();
+                if (v.is_prefix_implicit) {
+                    buf.push(`b.storeUint(${v.prefix_str}, ${v.prefix_len});`);
+                }
+                buf.push(emitStoreStatement(ctx, v.hasValueField ? `${tsExpr}.value` : tsExpr, v.variant_ty));
+                buf.push('break;').outdent();
+            }
+            buf.push('}');
+            return buf.toString();
+        }
+    }
+}
+// Emit a TS "store {expr of type ty} into builder `b`" callback (not expression).
+// Callbacks are passed for generics (user-defined generic types and built-ins),
+// e.g., `storeTolkNullable<T>(s, {callbackForT})`.
+function emitStoreCallback(ctx, ty) {
+    if (ty.kind === 'addressAny')
+        return codegen_ctx_1.RUNTIME.storeTolkAddressAny;
+    if (ty.kind === 'remaining')
+        return codegen_ctx_1.RUNTIME.storeTolkRemaining;
+    if (ty.kind === 'EnumRef')
+        return `${ty.enum_name}.store`;
+    if (ty.kind === 'genericT')
+        return `storeFn_${ty.name_t}`;
+    if (ty.kind === 'StructRef' && !ty.type_args)
+        return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.store`;
+    if (ty.kind === 'AliasRef' && !ty.type_args)
+        return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.store`;
+    // for simple statements, drop trailing `;` and use it as an expression:
+    // not `(v,b) => { b.storeInt(v, 8); }` but `(v,b) => b.storeInt(v, 8)`
+    let stmt = emitStoreStatement(ctx, 'v', ty);
+    if (stmt.indexOf(';') !== stmt.length - 1 || stmt.includes('\n') || stmt.includes('{')) {
+        stmt = '{ ' + stmt + ' }';
+    }
+    else if (stmt[stmt.length - 1] === ';') {
+        stmt = stmt.substring(0, stmt.length - 1);
+    }
+    return formatting_1.OutBuf.onNewLine(`(v,b) => ${stmt}`);
+}
+// Emit a TS "make a cell from {expr}" expression.
+// It's essentially beginCell + call storing callback + endCell.
+// Parameter `tsExpr` is a valid expression: "self.field", "v" (inside a callback), and other.
+function emitMakeCellFromExpr(ctx, tsExpr, ty, disableShortHand = false) {
+    if (disableShortHand) {
+        return `${codegen_ctx_1.RUNTIME.makeCellFrom}<${(0, emit_ts_types_1.emitTsType)(ctx, ty)}>(${tsExpr}, ${emitStoreCallback(ctx, ty)})`;
+    }
+    switch (ty.kind) {
+        case 'EnumRef': {
+            return `${(0, formatting_1.safeJsIdent)(ty.enum_name)}.toCell(${tsExpr})`;
+        }
+        case 'StructRef': {
+            if (ty.type_args) {
+                const cb = ty.type_args.map(ta => emitStoreCallback(ctx, ta)).join(', ');
+                return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.toCell<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${tsExpr}, ${cb})`;
+            }
+            return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.toCell(${tsExpr})`;
+        }
+        case 'AliasRef': {
+            if (ty.type_args) {
+                const cb = ty.type_args.map(ta => emitStoreCallback(ctx, ta)).join(', ');
+                return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.toCell<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${tsExpr}, ${cb})`;
+            }
+            return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.toCell(${tsExpr})`;
+        }
+        default:
+            return emitMakeCellFromExpr(ctx, tsExpr, ty, true);
+    }
+}
+// Emit a TS "StructName.create({bodyArg})" expression.
+// For instance, sendXXX and fromStorage methods accept struct fields and call create()
+// in order to enrich passed fields with `$` tag and default values.
+function emitCallToCreateMethodExpr(ctx, bodyArg, ty) {
+    if (ty.kind === 'StructRef') {
+        let structRef = ctx.symbols.getStruct(ty.struct_name);
+        if (structRef.fields.length === 0) {
+            bodyArg = ''; // create() is without arguments, body is an empty object
+        }
+        if (ty.type_args) {
+            return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.create<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${bodyArg})`;
+        }
+        return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.create(${bodyArg})`;
+    }
+    throw new Error(`can not emit create() call for ${ty.kind}`);
+}
+// Emit a key (de)serializer for c.Dictionary<K, V>.
+// Only a strict subset of KeyT is allowed by the @ton/core library.
+// For others, we can not generate wrappers at all (not only to/from cell, but even declarations).
+function emitDictKeySerializer(ctx, fieldPath, tyK) {
+    if (tyK.kind === 'intN')
+        return `c.Dictionary.Keys.BigInt(${tyK.n})`;
+    if (tyK.kind === 'uintN')
+        return `c.Dictionary.Keys.BigUint(${tyK.n})`;
+    if (tyK.kind === 'address')
+        return `c.Dictionary.Keys.Address()`;
+    throw new unsupported_errors_1.NonStandardDictKey(`'${fieldPath}' is 'map<${(0, types_kernel_1.renderTy)(tyK)}, ...>': such a non-standard map key can not be handled by @ton/core library`);
+}
+// Emit a value (de)serializer for c.Dictionary<K, V>.
+// Unlike keys, @ton/core allows arbitrary values (passing custom (de)serializers).
+// For common cases, use a built-in one; for others, create a custom.
+function emitDictValueSerializer(ctx, fieldPath, tyV) {
+    if (tyV.kind === 'intN')
+        return `c.Dictionary.Values.BigInt(${tyV.n})`;
+    if (tyV.kind === 'uintN')
+        return `c.Dictionary.Values.BigUint(${tyV.n})`;
+    if (tyV.kind === 'coins')
+        return `c.Dictionary.Values.BigVarUint(4)`;
+    if (tyV.kind === 'bool')
+        return `c.Dictionary.Values.Bool()`;
+    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, tyV)}>(${emitLoadCallback(ctx, fieldPath, tyV)}, ${emitStoreCallback(ctx, tyV)})`;
+}
+// Emit (de)serializers for c.Dictionary<K, V> (two arguments separated by a comma).
+function emitDictKVSerializers(ctx, fieldPath, tyK, tyV) {
+    return emitDictKeySerializer(ctx, fieldPath, tyK) + ', ' + emitDictValueSerializer(ctx, fieldPath, tyV);
+}

package/dist/emit-stack-rw.d.ts

@@ -0,0 +1,4 @@
+import type { Ty } from './abi-types';
+import { CodegenCtx } from './codegen-ctx';
+export declare function emitStackReadExpr(ctx: CodegenCtx, fieldPath: string, ty: Ty, unTupleIfW?: boolean): string;
+export declare function emitStackWriteItems(ctx: CodegenCtx, tsExpr: string, ty: Ty, tupleIfW?: boolean): string[];

package/dist/emit-stack-rw.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitStackReadExpr = emitStackReadExpr;
+exports.emitStackWriteItems = emitStackWriteItems;
+const codegen_ctx_1 = require("./codegen-ctx");
+const emit_ts_types_1 = require("./emit-ts-types");
+const formatting_1 = require("./formatting");
+const emit_pack_unpack_1 = require("./emit-pack-unpack");
+const unsupported_errors_1 = require("./unsupported-errors");
+const types_kernel_1 = require("./types-kernel");
+// Emit a TS "read {ty} from a stack `r`" expression.
+// Parameter `fieldPath` is used for error messages only.
+// Used to read getters return value, since contract getters work via the stack, not serialization.
+function emitStackReadExpr(ctx, fieldPath, ty, unTupleIfW = false) {
+    ctx.stackReadsUnknown || (ctx.stackReadsUnknown = ty.kind === 'unknown');
+    ctx.stackReadsArrayOf || (ctx.stackReadsArrayOf = ty.kind === 'arrayOf');
+    ctx.stackReadsLispListOf || (ctx.stackReadsLispListOf = ty.kind === 'lispListOf');
+    ctx.stackReadsSnakeString || (ctx.stackReadsSnakeString = ty.kind === 'string');
+    ctx.stackReadsTuple || (ctx.stackReadsTuple = ty.kind === 'arrayOf' || ty.kind === 'lispListOf' || ty.kind === 'shapedTuple');
+    ctx.stackReadsMapKV || (ctx.stackReadsMapKV = ty.kind === 'mapKV');
+    ctx.stackReadsBuilder || (ctx.stackReadsBuilder = ty.kind === 'builder');
+    ctx.stackReadsNullable || (ctx.stackReadsNullable = ty.kind === 'nullable');
+    ctx.stackReadsWideNullable || (ctx.stackReadsWideNullable = ty.kind === 'nullable' && ty.stack_type_id !== undefined);
+    ctx.stackReadsUnionType || (ctx.stackReadsUnionType = ty.kind === 'union');
+    ctx.stackReadsCellRef || (ctx.stackReadsCellRef = ty.kind === 'cellOf');
+    ctx.stackReadsNullLiteral || (ctx.stackReadsNullLiteral = ty.kind === 'nullLiteral');
+    if (unTupleIfW) { // inside `array<T>` or `[T, ...]`, if T is non-primitive, it's a sub-tuple
+        let wOnStack = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, ty);
+        if (wOnStack !== 1) {
+            return `r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, ty)}>(${wOnStack}, ${emitStackReadCallback(ctx, fieldPath, ty, false)})`;
+        }
+    }
+    switch (ty.kind) {
+        case 'int':
+        case 'intN':
+        case 'uintN':
+        case 'varintN':
+        case 'varuintN':
+        case 'coins': return `r.readBigInt()`;
+        case 'bool': return `r.readBoolean()`;
+        case 'cell': return `r.readCell()`;
+        case 'builder': return `r.readBuilder()`;
+        case 'slice': return `r.readSlice()`;
+        case 'string': return `r.readSnakeString()`;
+        case 'remaining': return `r.readSlice()`;
+        case 'address': return `r.readSlice().loadAddress()`;
+        case 'addressOpt': return emitStackReadExpr(ctx, fieldPath, { kind: 'nullable', inner: { kind: 'address' } });
+        case 'addressExt': return `r.readSlice().loadExternalAddress()`;
+        case 'addressAny': return `${codegen_ctx_1.RUNTIME.loadTolkAddressAny}(r.readSlice())`;
+        case 'bitsN': return `r.readSlice()`;
+        case 'nullLiteral': return `r.readNullLiteral()`;
+        case 'callable': throw new unsupported_errors_1.NotSupportedTypeOnStack(ty, fieldPath);
+        case 'void': return `void 0`;
+        case 'unknown': return `r.readUnknown()`;
+        case 'nullable': {
+            if (ty.stack_type_id) {
+                return `r.readWideNullable<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${ty.stack_width}, ${emitStackReadCallback(ctx, fieldPath, ty.inner, false)})`;
+            }
+            return `r.readNullable<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner, false)})`;
+        }
+        case 'cellOf': return `r.readCellRef<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${(0, emit_pack_unpack_1.emitLoadCallback)(ctx, fieldPath + '.ref', ty.inner)})`;
+        case 'arrayOf': return `r.readArrayOf<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner, true)})`;
+        case 'lispListOf': return `r.readLispListOf<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${emitStackReadCallback(ctx, fieldPath, ty.inner, true)})`;
+        case 'tensor': {
+            let buf = new formatting_1.OutBuf();
+            buf.push(`[`);
+            for (let i = 0; i < ty.items.length; ++i) {
+                buf.push(emitStackReadExpr(ctx, `${fieldPath}[${i}]`, ty.items[i]) + ',');
+            }
+            buf.push(']');
+            return buf.toString();
+        }
+        case 'shapedTuple': {
+            let buf = new formatting_1.OutBuf();
+            buf.push(`r.readTuple<${(0, emit_ts_types_1.emitTsType)(ctx, ty)}>(${ty.items.length}, (r) => [`);
+            for (let i = 0; i < ty.items.length; ++i) {
+                buf.push(emitStackReadExpr(ctx, `${fieldPath}[${i}]`, ty.items[i], true) + ',');
+            }
+            buf.push('])');
+            return buf.toString();
+        }
+        case 'mapKV': return `r.readDictionary<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.k, ty.v)}>(${(0, emit_pack_unpack_1.emitDictKVSerializers)(ctx, fieldPath, ty.k, ty.v)})`;
+        case 'EnumRef': return `r.readBigInt()`;
+        case 'StructRef': {
+            const structRef = ctx.symbols.getStruct(ty.struct_name);
+            let buf = new formatting_1.OutBuf();
+            buf.push(`({`);
+            buf.push(`$: '${ty.struct_name}',`);
+            for (let f of structRef.fields) {
+                const fTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(f.ty, structRef.type_params, ty.type_args) : f.ty;
+                buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${emitStackReadExpr(ctx, `${fieldPath}.${f.name}`, fTy)},`);
+            }
+            buf.push(`})`);
+            return buf.toString();
+        }
+        case 'AliasRef': {
+            const aliasRef = ctx.symbols.getAlias(ty.alias_name);
+            const targetTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(aliasRef.target_ty, aliasRef.type_params, ty.type_args) : aliasRef.target_ty;
+            return emitStackReadExpr(ctx, fieldPath, targetTy);
+        }
+        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} in '${fieldPath}'`);
+        case 'union': {
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
+            let buf = new formatting_1.OutBuf();
+            buf.push(`r.readUnionType<${(0, emit_ts_types_1.emitTsType)(ctx, ty)}>(${ty.stack_width}, {`);
+            for (let v of variants) {
+                buf.push(`${v.stack_type_id}: [${v.stack_width}, ${v.hasValueField ? `'${v.labelStr}'` : 'null'}, ${emitStackReadCallback(ctx, `${fieldPath}#${v.stack_type_id}`, v.variant_ty, false)}],`);
+            }
+            buf.push(`})`);
+            return buf.toString();
+        }
+    }
+}
+// Emit a TS "read {ty} from a stack `r`" callback (not expression).
+// Callbacks are passed for generics — for example, to read a nullable (when a stack slot is not null).
+function emitStackReadCallback(ctx, fieldPath, ty, unTupleIfW) {
+    return formatting_1.OutBuf.onNewLine(`(r) => ${emitStackReadExpr(ctx, fieldPath, ty, unTupleIfW)}`);
+}
+// Emit a TS "write {expr of type ty} to a stack" expression compatible with @ton/core TupleItem.
+// Used to pass getters arguments, since contract getters work via the stack, not serialization.
+// Parameter `tsExpr` is a valid expression: "p1.field", "p2[0]", "ith" (inside a callback), and other.
+function emitStackWriteItems(ctx, tsExpr, ty, tupleIfW = false) {
+    if (tupleIfW) { // inside `array<T>` or `[T, ...]`, if T is non-primitive, it's a sub-tuple
+        if ((0, types_kernel_1.calcWidthOnStack)(ctx.symbols, ty) === 1) {
+            return emitStackWriteItems(ctx, tsExpr, ty, false);
+        }
+        let buf = new formatting_1.OutBuf();
+        buf.push(`{ type: 'tuple', items: [`);
+        for (let line of emitStackWriteItems(ctx, tsExpr, ty, false)) {
+            buf.push(line + ',');
+        }
+        buf.push(`]}`);
+        return [buf.toString()];
+    }
+    switch (ty.kind) {
+        case 'int':
+        case 'intN':
+        case 'uintN':
+        case 'varintN':
+        case 'varuintN':
+        case 'coins': return [`{ type: 'int', value: ${tsExpr} }`];
+        case 'bool': return [`{ type: 'int', value: (${tsExpr} ? -1n : 0n) }`];
+        case 'cell': return [`{ type: 'cell', cell: ${tsExpr} }`];
+        case 'builder': return [`{ type: 'builder', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
+        case 'slice': return [`{ type: 'slice', cell: ${codegen_ctx_1.RUNTIME.beginCell}().storeSlice(${tsExpr}).endCell() }`];
+        case 'string': return [`{ type: 'cell', cell: ${codegen_ctx_1.RUNTIME.beginCell}().storeStringTail(${tsExpr}).endCell() }`];
+        case 'remaining': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
+        case 'address': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
+        case 'addressOpt': return emitStackWriteItems(ctx, tsExpr, { kind: 'nullable', inner: { kind: 'address' } });
+        case 'addressExt': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
+        case 'addressAny': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
+        case 'bitsN': return [`{ type: 'slice', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, tsExpr, ty)} }`];
+        case 'nullLiteral': return [`{ type: 'null' }`];
+        case 'callable': throw new unsupported_errors_1.NotSupportedTypeOnStack(ty, tsExpr);
+        case 'void': return [];
+        case 'unknown': return [tsExpr];
+        case 'nullable': {
+            if (ty.stack_type_id) {
+                let buf = new formatting_1.OutBuf();
+                buf.push(`...(`);
+                buf.push(`${tsExpr} === null ? [`);
+                for (let i = 0; i < ty.stack_width - 1; ++i) {
+                    buf.push(`{ type: 'null' },`);
+                }
+                buf.push(`{ type: 'int', value: 0n },`);
+                buf.push(`] : [`);
+                emitStackWriteItems(ctx, tsExpr, ty.inner).forEach(w => buf.push(w + ','));
+                buf.push(`{ type: 'int', value: ${ty.stack_type_id}n },`);
+                buf.push(`]`);
+                buf.push(`) as c.TupleItem[]`);
+                return [buf.toString()];
+            }
+            return [`${tsExpr} === null ? { type: 'null' } : ${emitStackWriteItems(ctx, tsExpr, ty.inner)[0]}`];
+        }
+        case 'cellOf': return [`{ type: 'cell', cell: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, `${tsExpr}.ref`, ty.inner)} }`];
+        case 'arrayOf': return [`{ type: 'tuple', items: ${tsExpr}.map(${formatting_1.OutBuf.onNewLine(`(ith) => (${emitStackWriteItems(ctx, 'ith', ty.inner, true)})`)})}`];
+        case 'tensor': return ty.items.flatMap((item, idx) => emitStackWriteItems(ctx, `${tsExpr}[${idx}]`, item));
+        case 'shapedTuple': {
+            let buf = new formatting_1.OutBuf();
+            buf.push(`{ type: 'tuple', items: [`);
+            for (let i = 0; i < ty.items.length; ++i) {
+                buf.push(emitStackWriteItems(ctx, `${tsExpr}[${i}]`, ty.items[i], true)[0] + ',');
+            }
+            buf.push(']}');
+            return [buf.toString()];
+        }
+        case 'lispListOf': {
+            let buf = new formatting_1.OutBuf();
+            buf.push(`${tsExpr}.reduceRight((tail, head) => ({ type: 'tuple', items: [`);
+            buf.push(emitStackWriteItems(ctx, `head`, ty.inner, true)[0] + ',');
+            buf.push('tail');
+            buf.push(`]}), { type: 'null' } as c.TupleItem)`);
+            return [buf.toString()];
+        }
+        case 'mapKV': return [`${tsExpr}.size === 0 ? { type: 'null' } : { type: 'cell', cell: ${codegen_ctx_1.RUNTIME.beginCell}().storeDictDirect<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.k, ty.v)}>(${tsExpr}, ${(0, emit_pack_unpack_1.emitDictKVSerializers)(ctx, tsExpr, ty.k, ty.v)}).endCell() }`];
+        case 'EnumRef': return [`{ type: 'int', value: ${tsExpr} }`];
+        case 'StructRef': {
+            const structRef = ctx.symbols.getStruct(ty.struct_name);
+            return structRef.fields.flatMap(f => {
+                const fTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(f.ty, structRef.type_params, ty.type_args) : f.ty;
+                return emitStackWriteItems(ctx, `${tsExpr}.${f.name}`, fTy);
+            });
+        }
+        case 'AliasRef': {
+            const aliasRef = ctx.symbols.getAlias(ty.alias_name);
+            const targetTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(aliasRef.target_ty, aliasRef.type_params, ty.type_args) : aliasRef.target_ty;
+            return emitStackWriteItems(ctx, tsExpr, targetTy);
+        }
+        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} in '${tsExpr}'`);
+        case 'union': {
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
+            variants.sort((a, b) => a.stack_type_id - b.stack_type_id); // move `null` variant (if exists) to the top
+            let buf = new formatting_1.OutBuf();
+            buf.push(`...(`);
+            for (let v of variants) {
+                if (v.labelStr === '')
+                    buf.push(`${tsExpr} === null ? [`);
+                else
+                    buf.push(`${tsExpr}.$ === '${v.labelStr}' ? [`);
+                for (let i = 0; i < ty.stack_width - 1 - v.stack_width; ++i) {
+                    buf.push(`{ type: 'null' },`);
+                }
+                emitStackWriteItems(ctx, v.hasValueField ? tsExpr + '.value' : tsExpr, v.variant_ty).forEach(w => buf.push(w + ','));
+                buf.push(`{ type: 'int', value: ${v.stack_type_id}n },`);
+                buf.push(`] :`);
+            }
+            buf.push(`(() => { throw new Error('invalid $ field in a union') })()`);
+            buf.push(`) as c.TupleItem[]`);
+            return [buf.toString()];
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { Ty } from './abi-types';
+import { CodegenCtx } from './codegen-ctx';
+import { UnionVariantLabeled } from './types-kernel';
+export declare function emitUnionLabelAndValue(label: UnionVariantLabeled, contents: string): string;
+export declare function emitTsType(ctx: CodegenCtx, ty: Ty): string;
+export declare function emitDictKVTypeArgs(ctx: CodegenCtx, tyK: Ty, tyV: Ty): string;

package/dist/emit-ts-types.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitUnionLabelAndValue = emitUnionLabelAndValue;
+exports.emitTsType = emitTsType;
+exports.emitDictKVTypeArgs = emitDictKVTypeArgs;
+const formatting_1 = require("./formatting");
+const types_kernel_1 = require("./types-kernel");
+// Given a union `T1 | T2` after detecting whether each `T_i` should have `$ + value`,
+// stringify it
+function emitUnionLabelAndValue(label, contents) {
+    return label.hasValueField ? `{ $: '${label.labelStr}', value: ${contents} }` : contents;
+}
+// Convert any Tolk type (ABI representation) to a corresponding TypeScript type.
+// Tolk `int32` -> TS `bigint`, but for readability, `type int32 = bigint` is created.
+// `c.` is import @ton/core.
+function emitTsType(ctx, ty) {
+    if (ty.kind === 'intN')
+        ctx.intNOccurred.add(`int${ty.n}`);
+    if (ty.kind === 'uintN')
+        ctx.uintNOccurred.add(`uint${ty.n}`);
+    if (ty.kind === 'varintN')
+        ctx.varIntNOccurred.add(`varint${ty.n}`);
+    if (ty.kind === 'varuintN')
+        ctx.varIntNOccurred.add(`varuint${ty.n}`);
+    if (ty.kind === 'bitsN')
+        ctx.bitsNOccurred.add(`bits${ty.n}`);
+    if (ty.kind === 'remaining')
+        ctx.has_RemainingBitsAndRefs = true;
+    if (ty.kind === 'addressAny')
+        ctx.has_addressAny = true;
+    if (ty.kind === 'arrayOf')
+        ctx.has_arrayOf = true;
+    if (ty.kind === 'lispListOf')
+        ctx.has_lispListOf = true;
+    switch (ty.kind) {
+        case 'int': return `bigint`;
+        case 'intN': return `int${ty.n}`;
+        case 'uintN': return `uint${ty.n}`;
+        case 'varintN': return `varint${ty.n}`;
+        case 'varuintN': return `varuint${ty.n}`;
+        case 'coins': return `coins`;
+        case 'bool': return `boolean`;
+        case 'cell': return `c.Cell`;
+        case 'builder': return `c.Builder`;
+        case 'slice': return `c.Slice`;
+        case 'string': return 'string';
+        case 'remaining': return `RemainingBitsAndRefs`;
+        case 'address': return `c.Address`;
+        case 'addressOpt': return `c.Address | null`;
+        case 'addressExt': return `c.ExternalAddress`;
+        case 'addressAny': return `any_address`;
+        case 'bitsN': return `bits${ty.n}`;
+        case 'nullLiteral': return `null`;
+        case 'callable': return `any`;
+        case 'void': return `void`;
+        case 'unknown': return `c.TupleItem`;
+        case 'nullable': return `${emitTsType(ctx, ty.inner)} | null`;
+        case 'cellOf': return `CellRef<${emitTsType(ctx, ty.inner)}>`;
+        case 'arrayOf': return `array<${emitTsType(ctx, ty.inner)}>`;
+        case 'lispListOf': return `lisp_list<${emitTsType(ctx, ty.inner)}>`;
+        case 'tensor': return `[${ty.items.map(item => emitTsType(ctx, item)).join(', ')}]`;
+        case 'shapedTuple': return `[${ty.items.map(item => emitTsType(ctx, item)).join(', ')}]`;
+        case 'mapKV': return `c.Dictionary<${emitDictKVTypeArgs(ctx, ty.k, ty.v)}>`;
+        case 'EnumRef': return ty.enum_name;
+        case 'StructRef': return (0, formatting_1.safeJsIdent)(ty.struct_name) + (ty.type_args ? `<${ty.type_args.map(ta => emitTsType(ctx, ta)).join(', ')}>` : '');
+        case 'AliasRef': return (0, formatting_1.safeJsIdent)(ty.alias_name) + (ty.type_args ? `<${ty.type_args.map(ta => emitTsType(ctx, ta)).join(', ')}>` : '');
+        case 'genericT': return ty.name_t;
+        case 'union': return (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants).map(v => emitUnionLabelAndValue(v, emitTsType(ctx, v.variant_ty))).join(' | ');
+    }
+}
+// Emit c.Dictionary<K, V> (K and V — inside brackets, two types separated by comma).
+function emitDictKVTypeArgs(ctx, tyK, tyV) {
+    return emitTsType(ctx, tyK) + ', ' + emitTsType(ctx, tyV);
+}

package/dist/formatting.d.ts

@@ -0,0 +1,15 @@
+export declare class OutBuf {
+    static TAB: string;
+    static onNewLine(s: string): string;
+    private static indentNested;
+    private lines;
+    private indentLevel;
+    indent(): void;
+    outdent(): void;
+    emptyLine(): void;
+    push(line: string): this;
+    toString(): string;
+}
+export declare function safeJsIdent(tolkIdentifier: string): string;
+export declare function safeFieldDecl(fieldName: string): string;
+export declare function safeFieldRead(fieldName: string): string;