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

package/dist/out-template.generated.js

@@ -0,0 +1,6 @@
+"use strict";
+// AUTO-GENERATED FILE. DO NOT EDIT.
+// 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            throw new Error(`not '${itemType}' on a stack`);\n        }\n        return item as ItemT;\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.popExpecting<c.TupleItemCell>('cell').cell;\n    }\n\n    readSlice(): c.Slice {\n        return this.popExpecting<c.TupleItemSlice>('slice').cell.beginParse();\n    }\n\n    // {{if:stackReadsBuilder}}\n    readBuilder(): c.Builder {\n        return beginCell().storeSlice(this.popExpecting<c.TupleItemBuilder>('builder').cell.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,          // todo will somebody need special?\n        libraries: null,        // todo will somebody need libraries?\n    })).endCell();\n\n    let addrHash = stateInitCell.hash();\n    if (options.toShard) {\n        const shardDepth = options.toShard.fixedPrefixLength;\n        addrHash = beginCell()  // todo any way to do it better? N bits from closeTo + 256-N from stateInitCell\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";

package/dist/tolk-to-abi.d.ts

@@ -0,0 +1,2 @@
+import type { ContractABI } from './abi';
+export declare function convertTolkFileToABI(absFileName: string): Promise<ContractABI>;

package/dist/tolk-to-abi.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertTolkFileToABI = convertTolkFileToABI;
+const fs_1 = __importDefault(require("fs"));
+const tolk_js_1 = require("@ton/tolk-js");
+// This function is used ONLY for development (when tolk-js is installed),
+// it is not exposed as public API.
+async function convertTolkFileToABI(absFileName) {
+    let compileResult = await (0, tolk_js_1.runTolkCompiler)({
+        entrypointFileName: absFileName,
+        fsReadCallback: path => fs_1.default.readFileSync(path, 'utf-8'),
+    });
+    if (compileResult.status === 'error') {
+        throw new Error(`Can not compile with tolk-js: ${compileResult.message}`);
+    }
+    let json = compileResult.abiJson;
+    json.codeBoc64 = compileResult.codeBoc64;
+    return json;
+}

package/dist/types-kernel.d.ts

@@ -0,0 +1,10 @@
+import type { Ty, UnionVariant } from './abi-types';
+import { SymTable } from './codegen-ctx';
+export declare function renderTy(ty: Ty): string;
+export interface UnionVariantLabeled extends UnionVariant {
+    labelStr: string;
+    hasValueField: boolean;
+}
+export declare function createLabelsForUnion(symbols: SymTable, variants: UnionVariant[]): UnionVariantLabeled[];
+export declare function instantiateGenerics(ty: Ty, typeParams: string[] | undefined, typeArgs: Ty[]): Ty;
+export declare function calcWidthOnStack(symbols: SymTable, ty: Ty): number;

package/dist/types-kernel.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTy = renderTy;
+exports.createLabelsForUnion = createLabelsForUnion;
+exports.instantiateGenerics = instantiateGenerics;
+exports.calcWidthOnStack = calcWidthOnStack;
+/*
+    Contains basic functions working with ABI types,
+  which are used both for generating wrappers and dynamic serialization.
+    They do not emit TypeScript expressions and do not depend on CodegenCtx and DynamicCtx.
+ */
+// Render intermediate representation back to a valid Tolk type, exactly as it was in original sources.
+function renderTy(ty) {
+    switch (ty.kind) {
+        case 'int': return `int`;
+        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 `bool`;
+        case 'cell': return `cell`;
+        case 'builder': return `builder`;
+        case 'slice': return `slice`;
+        case 'string': return `string`;
+        case 'remaining': return `RemainingBitsAndRefs`;
+        case 'address': return `address`;
+        case 'addressOpt': return `address?`;
+        case 'addressExt': return `ext_address`;
+        case 'addressAny': return `any_address`;
+        case 'bitsN': return `bits${ty.n}`;
+        case 'nullLiteral': return `null`;
+        case 'callable': return `continuation`;
+        case 'void': return `void`;
+        case 'unknown': return `unknown`;
+        case 'nullable': return `${renderTy(ty.inner)}?`;
+        case 'cellOf': return `Cell<${renderTy(ty.inner)}>`;
+        case 'arrayOf': return `array<${renderTy(ty.inner)}>`;
+        case 'lispListOf': return `lisp_list<${renderTy(ty.inner)}>`;
+        case 'tensor': return `(${ty.items.map(renderTy).join(', ')})`;
+        case 'shapedTuple': return `[${ty.items.map(renderTy).join(', ')}]`;
+        case 'mapKV': return `map<${renderTy(ty.k)}, ${renderTy(ty.v)}>`;
+        case 'EnumRef': return ty.enum_name;
+        case 'StructRef': return ty.struct_name + (ty.type_args ? `<${ty.type_args.map(renderTy).join(', ')}>` : '');
+        case 'AliasRef': return ty.alias_name + (ty.type_args ? `<${ty.type_args.map(renderTy).join(', ')}>` : '');
+        case 'genericT': return ty.name_t;
+        case 'union': return ty.variants.map(v => renderTy(v.variant_ty)).join(' | ');
+    }
+}
+// A "label" is the `$` field in TypeScript output, used to differentiate structs and union variants.
+// Tolk `int32 | int64` -> TS `{ $: 'int32', value: bigint } | { $: 'int64', value: bigint }`.
+// This function creates a string for `$`.
+function createLabel(symbols, ty) {
+    switch (ty.kind) {
+        case 'int': return `int`;
+        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 `bool`;
+        case 'cell': return `cell`;
+        case 'builder': return `builder`;
+        case 'slice': return `slice`;
+        case 'string': return `string`;
+        case 'remaining': return `RemainingBitsAndRefs`;
+        case 'address': return `address`;
+        case 'addressOpt': return `address?`;
+        case 'addressExt': return `ext_address`;
+        case 'addressAny': return `any_address`;
+        case 'bitsN': return `bits${ty.n}`;
+        case 'nullLiteral': return `null`;
+        case 'callable': return `callable`;
+        case 'void': return `void`;
+        case 'unknown': return `unknown`;
+        case 'nullable': return `${createLabel(symbols, ty.inner)}?`;
+        case 'cellOf': return `Cell`;
+        case 'arrayOf': return `array`;
+        case 'lispListOf': return `lisp_list`;
+        case 'tensor': return `tensor`;
+        case 'shapedTuple': return `shaped`;
+        case 'mapKV': return `map`;
+        case 'EnumRef': return ty.enum_name;
+        case 'StructRef': return ty.struct_name;
+        case 'AliasRef': return createLabel(symbols, symbols.getAliasTarget(ty.alias_name));
+        case 'genericT': return ty.name_t;
+        case 'union': return ty.variants.map(v => createLabel(symbols, v.variant_ty)).join('|');
+    }
+}
+// Every Tolk struct is generated as TS `interface` with `$` field.
+// Tolk `struct A { ... }` -> TS `interface A { $: 'A', ... }`.
+// So, Tolk `A | B` is represented as TS `A | B` (unlike primitives),
+// because every struct has its own label.
+function isStructWithItsOwnLabel(symbols, ty) {
+    if (ty.kind === 'StructRef')
+        return true;
+    if (ty.kind === 'AliasRef')
+        return isStructWithItsOwnLabel(symbols, symbols.getAliasTarget(ty.alias_name));
+    return false;
+}
+// Given a union `T1 | T2 | ...`, calculate a TypeScript representation:
+// whether each variant should be `$ + value` or not, and what string does `$` hold.
+function createLabelsForUnion(symbols, variants) {
+    // in all practical cases, `T_i` is a structure or a primitive;
+    // we try to shorten a label (`createLabel()` is a "simple string of a type"):
+    // - for a generic struct, use `Wrapper`, not `Wrapper<xxx>`
+    // - for `Cell<...>`, use a shorthand `Cell`
+    // - etc.
+    // but if it results in a duplicate (e.g. `Wrapper<int32> | Wrapper<int64>` => ['Wrapper','Wrapper']),
+    // then full-string Tolk types are used, and `value` is always required:
+    // `type U = { $: 'Wrapper<int32>', value: Wrapper<int32> } | ...`
+    let unique = new Set();
+    let hasDuplicates = false;
+    variants.forEach(variant => {
+        let labelStr = createLabel(symbols, variant.variant_ty);
+        hasDuplicates || (hasDuplicates = unique.has(labelStr));
+        unique.add(labelStr);
+    });
+    return variants.map(variant => {
+        let variantTy = variant.variant_ty;
+        if (variantTy.kind === 'nullLiteral') {
+            return { ...variant, labelStr: '', hasValueField: false };
+        }
+        return {
+            ...variant,
+            labelStr: hasDuplicates ? renderTy(variantTy) : createLabel(symbols, variantTy),
+            hasValueField: hasDuplicates ? true : !isStructWithItsOwnLabel(symbols, variantTy)
+        };
+    });
+}
+// Replace all generic Ts (typeParams) with instantiation (typeArgs) recursively.
+// Example: `(int, T, Wrapper<T?>)` and T=coins => `(int, coins, Wrapper<coins?>)`
+function instantiateGenerics(ty, typeParams, typeArgs) {
+    if (ty.kind === 'nullable')
+        return { ...ty, inner: instantiateGenerics(ty.inner, typeParams, typeArgs) };
+    if (ty.kind === 'cellOf')
+        return { ...ty, inner: instantiateGenerics(ty.inner, typeParams, typeArgs) };
+    if (ty.kind === 'arrayOf')
+        return { ...ty, inner: instantiateGenerics(ty.inner, typeParams, typeArgs) };
+    if (ty.kind === 'lispListOf')
+        return { ...ty, inner: instantiateGenerics(ty.inner, typeParams, typeArgs) };
+    if (ty.kind === 'tensor')
+        return { ...ty, items: ty.items.map(item => instantiateGenerics(item, typeParams, typeArgs)) };
+    if (ty.kind === 'shapedTuple')
+        return { ...ty, items: ty.items.map(item => instantiateGenerics(item, typeParams, typeArgs)) };
+    if (ty.kind === 'mapKV')
+        return { ...ty, k: instantiateGenerics(ty.k, typeParams, typeArgs), v: instantiateGenerics(ty.v, typeParams, typeArgs) };
+    if (ty.kind === 'StructRef')
+        return { ...ty, type_args: ty.type_args?.map(ta => instantiateGenerics(ta, typeParams, typeArgs)) };
+    if (ty.kind === 'AliasRef')
+        return { ...ty, type_args: ty.type_args?.map(ta => instantiateGenerics(ta, typeParams, typeArgs)) };
+    if (ty.kind === 'union')
+        return { ...ty, variants: ty.variants.map(v => ({ ...v, variant_ty: instantiateGenerics(v.variant_ty, typeParams, typeArgs) })) };
+    if (ty.kind === 'genericT') {
+        const idx = typeParams?.indexOf(ty.name_t);
+        if (idx === undefined || idx === -1 || idx >= typeArgs.length)
+            throw new Error(`inconsistent generics: could not find type argument for ${ty.name_t}`);
+        return typeArgs[idx];
+    }
+    return ty;
+}
+// Calculate, how many stack slots a type occupies.
+function calcWidthOnStack(symbols, ty) {
+    switch (ty.kind) {
+        case 'void': {
+            // void is like "unit", equal to an empty tensor
+            return 0;
+        }
+        case 'tensor': {
+            // a tensor is a sum of its elements
+            return ty.items.map(item => calcWidthOnStack(symbols, item)).reduce((p, c) => p + c, 0);
+        }
+        case 'StructRef': {
+            // a struct is a named tensor: fields one by one;
+            // if a struct is generic `Wrapper<T>`, we have typeArgs T=xxx, and replace T in each field
+            // (it works unless `T` is used in unions)
+            const structRef = symbols.getStruct(ty.struct_name);
+            return structRef.fields.map(f => {
+                const fTy = ty.type_args ? instantiateGenerics(f.ty, structRef.type_params, ty.type_args) : f.ty;
+                return calcWidthOnStack(symbols, fTy);
+            }).reduce((p, c) => p + c, 0);
+        }
+        case 'AliasRef': {
+            // an alias is the same as its underlying (target) type;
+            // if an alias is generic `Maybe<T>`, we have typeArgs T=xxx, and replace T in its target
+            const aliasRef = symbols.getAlias(ty.alias_name);
+            const targetTy = ty.type_args ? instantiateGenerics(aliasRef.target_ty, aliasRef.type_params, ty.type_args) : aliasRef.target_ty;
+            return calcWidthOnStack(symbols, targetTy);
+        }
+        case 'nullable': {
+            // for primitive nullables (common case), like `int?` and `address?`, it's 1 (TVM value or NULL);
+            // for non-primitive nullables, the compiler inserts stackWidth and stackTypeId
+            return ty.stack_width ?? 1;
+        }
+        case 'union': {
+            // for union types, the compiler always inserts stackWidth for simplicity (and stackTypeId for each variant)
+            return ty.stack_width;
+        }
+        case 'genericT': {
+            // all generics must have been instantiated up to this point
+            throw new Error(`unexpected genericT=${ty.name_t} in calcWidthOnStack`);
+        }
+        default: {
+            // almost all types are TVM primitives that occupy 1 stack slot:
+            // - intN is TVM INT
+            // - array<T> is TVM TUPLE
+            // - map<K, V> is TVM DICT or NULL
+            // etc.
+            return 1;
+        }
+    }
+}

package/dist/unsupported-errors.d.ts

@@ -0,0 +1,28 @@
+import type { Ty } from './abi-types';
+export declare class SymbolNotFound extends Error {
+    constructor(symbolKind: string, notFoundName: string);
+}
+export declare class CantGeneratePackUnpack extends Error {
+    constructor(message: string);
+}
+export declare class NonStandardDictKey extends Error {
+    constructor(message: string);
+}
+export declare class NotSupportedTypeOnStack extends Error {
+    constructor(ty: Ty, fieldPath: string);
+}
+export declare class CantGenerateWrappersAtAll extends Error {
+    constructor(where: string, prevEx: any);
+}
+export declare class InvalidDynamicInput extends Error {
+    constructor(msg: string);
+}
+export declare class CantPackDynamic extends Error {
+    constructor(fieldPath: string, msg: string);
+}
+export declare class CantUnpackDynamic extends Error {
+    constructor(fieldPath: string, msg: string);
+}
+export declare class CantCallGetMethodDynamic extends Error {
+    constructor(getMethodName: string, msg: string);
+}

package/{src/unsupported-errors.ts → dist/unsupported-errors.js}

@@ -1,82 +1,76 @@
-import type { Ty } from './abi-types';
-import { renderTy } from './types-kernel'
-
-// Fired when LSP (temporary used for parsing Tolk files into ABI)
-// can not be initialized, or has unresolved types, or other errors while parsing Tolk sources.
-export class CantParseInputTolkFile extends Error {
-    constructor(message: string) {
-        super(message);
-    }
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CantCallGetMethodDynamic = exports.CantUnpackDynamic = exports.CantPackDynamic = exports.InvalidDynamicInput = exports.CantGenerateWrappersAtAll = exports.NotSupportedTypeOnStack = exports.NonStandardDictKey = exports.CantGeneratePackUnpack = exports.SymbolNotFound = void 0;
+const types_kernel_1 = require("./types-kernel");
 // Fired when TyRef contains unresolved symbols,
-// e.g. { kind: 'StructRef', structName: 'non-existing' }
-export class SymbolNotFound extends Error {
-    constructor(symbolKind: string, notFoundName: string) {
+// e.g. { kind: 'StructRef', struct_name: 'non-existing' }
+class SymbolNotFound extends Error {
+    constructor(symbolKind, notFoundName) {
         super(`${symbolKind} ${notFoundName} not found`);
     }
 }
-
+exports.SymbolNotFound = SymbolNotFound;
 // Fired if serialization to/from cells can not be applied to a specific type/struct.
 // E.g., a struct contains `int` (not int32/uint64): it's used only in contract getters.
 // For such structs, `fromSlice`/`store` is just `throw` with description
 // (the overall process of generating wrappers continues, only a specific struct can't be serialized).
-export class CantGeneratePackUnpack extends Error {
-    constructor(message: string) {
+class CantGeneratePackUnpack extends Error {
+    constructor(message) {
         super(message);
     }
 }
-
+exports.CantGeneratePackUnpack = CantGeneratePackUnpack;
 // `Dictionary<K, V>` from @ton/core allows only predefined KeyT.
 // For others, we can not generate wrappers at all (not only to/from cell, but even declarations).
-export class NonStandardDictKey extends Error {
-    constructor(message: string) {
+class NonStandardDictKey extends Error {
+    constructor(message) {
         super(message);
     }
 }
-
+exports.NonStandardDictKey = NonStandardDictKey;
 // Some types, like callables/lambdas, can not be used in get methods, we can't generate wrappers then.
-export class NotSupportedTypeOnStack extends Error {
-    constructor(ty: Ty, fieldPath: string) {
-        super(`'${fieldPath}' can not be used in get methods, because it contains '${renderTy(ty)}'`);
+class NotSupportedTypeOnStack extends Error {
+    constructor(ty, fieldPath) {
+        super(`'${fieldPath}' can not be used in get methods, because it contains '${(0, types_kernel_1.renderTy)(ty)}'`);
     }
 }
-
+exports.NotSupportedTypeOnStack = NotSupportedTypeOnStack;
 // This error is fired "to the outer world".
-export class CantGenerateWrappersAtAll extends Error {
-    constructor(where: string, prevEx: any) {
+class CantGenerateWrappersAtAll extends Error {
+    constructor(where, prevEx) {
         super(`${where}: [${prevEx.constructor.name}] ${prevEx.message ?? prevEx.toString()}`);
     }
 }
-
+exports.CantGenerateWrappersAtAll = CantGenerateWrappersAtAll;
 // This error is fired when invalid input is passed into dynamic serialization.
 // For example, passed an object instead of a number, a field is missing, etc.
-export class InvalidDynamicInput extends Error {
-    constructor(msg: string) {
+class InvalidDynamicInput extends Error {
+    constructor(msg) {
         super(msg);
     }
 }
-
+exports.InvalidDynamicInput = InvalidDynamicInput;
 // This error is fired when dynamic serialization (from a JS object to a cell) failed.
 // For example, passed an object instead of a number, a field is missing, etc.
-export class CantPackDynamic extends Error {
-    constructor(fieldPath: string, msg: string) {
+class CantPackDynamic extends Error {
+    constructor(fieldPath, msg) {
         super(`cannot serialize '${fieldPath}' dynamically: ${msg}`);
     }
 }
-
+exports.CantPackDynamic = CantPackDynamic;
 // This error is fired when dynamic deserialization (from a cell into a JS object) failed.
 // For example, none of union prefixes match.
-export class CantUnpackDynamic extends Error {
-    constructor(fieldPath: string, msg: string) {
+class CantUnpackDynamic extends Error {
+    constructor(fieldPath, msg) {
         super(`cannot deserialize '${fieldPath}' dynamically: ${msg}`);
     }
 }
-
+exports.CantUnpackDynamic = CantUnpackDynamic;
 // This error is fired when dynamic calling get method (from a JS object to a TVM tuple) failed.
 // For example, passed an object instead of a number, a field is missing, etc.
-export class CantCallGetMethodDynamic extends Error {
-    constructor(getMethodName: string, msg: string) {
+class CantCallGetMethodDynamic extends Error {
+    constructor(getMethodName, msg) {
         super(`cannot call get method '${getMethodName}' dynamically: ${msg}`);
     }
 }
+exports.CantCallGetMethodDynamic = CantCallGetMethodDynamic;

package/package.json

@@ -1,32 +1,78 @@
 {
-    "name": "gen-typescript-from-tolk-dev",
-    "version": "0.1.0",
-    "author": "TON Core",
-    "files": [
-        "README.md",
-        "bin",
-        "src",
-        "tsconfig.json"
-    ],
-    "bin": {
-        "gen-typescript-from-tolk": "./bin/generator.js"
+  "name": "gen-typescript-from-tolk-dev",
+  "version": "0.2.0",
+  "description": "Generate TypeScript wrappers from Tolk ABI",
+  "author": "TON Core",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
     },
-    "scripts": {
-        "build:standalone": "node scripts/build-standalone-cli.js",
-        "test": "jest --verbose"
+    "./src/*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js",
+      "require": "./dist/*.js",
+      "default": "./dist/*.js"
     },
-    "dependencies": {
-        "@ton/core": "~0",
-        "ts-node": "^10.9.2",
-        "typescript": "^5.9.2"
-    },
-    "devDependencies": {
-        "@ton/crypto": "^3.3.0",
-        "@ton/sandbox": ">=0.37.0",
-        "@ton/ton": ">=15.3.1 <16.0.0",
-        "@types/jest": "^30.0.0",
-        "@types/node": "^22.17.2",
-        "jest": "^30.0.5",
-        "ts-jest": "^29.4.1"
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "src/*": [
+        "dist/*"
+      ]
     }
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "bin": "./bin/generator.js",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tolk-vm/gen-typescript-from-tolk.git"
+  },
+  "keywords": [
+    "ton",
+    "tolk",
+    "typescript",
+    "abi",
+    "wrappers"
+  ],
+  "scripts": {
+    "sync:template": "node scripts/sync-out-template.js",
+    "clean": "node --eval \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && npm run sync:template && tsc -p tsconfig.build.json",
+    "typecheck": "npm run sync:template && tsc -p tsconfig.json",
+    "test": "npm run sync:template && jest --config jest.config.js --verbose",
+    "check": "npm run build && npm test",
+    "pack:dry-run": "npm pack --dry-run",
+    "prepack": "npm run build",
+    "dev:codegen": "npm run sync:template && ts-node dev-codegen.ts"
+  },
+  "dependencies": {
+    "@ton/core": "0.62.0"
+  },
+  "devDependencies": {
+    "@ton/crypto": "3.3.0",
+    "@ton/sandbox": "0.37.2",
+    "@ton/ton": "15.4.0",
+    "@types/jest": "30.0.0",
+    "@types/node": "22.18.8",
+    "jest": "30.2.0",
+    "ts-jest": "29.4.4",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.3"
+  }
 }