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

package/README.md

@@ -1,47 +1,51 @@
-# Tolk-to-TypeScript wrappers generator (alpha)
+# gen-typescript-from-tolk
 
-Currently, it uses a patched LSP to parse and Tolk source code (for MVP). Later, the compiler will be able
-to emit ABI of a contract, and LSP won't be used in this process.
+Generate production-ready TypeScript wrappers from a prebuilt Tolk ABI.
 
-### Main CLI
-
-The main entrypoint accepts contract ABI as a JSON string and prints the generated TypeScript wrapper to stdout:
+## Install
 
 ```bash
-npx gen-typescript-from-tolk '{"contractName":"MyContract", ... }'
+npm install gen-typescript-from-tolk
 ```
 
-This package no longer bundles a Tolk compiler. It only supports `ABI JSON -> TypeScript wrapper`.
+## Library usage
 
+```ts
+import { generateTypeScriptFileForContract } from 'gen-typescript-from-tolk';
+import type { ContractABI } from 'gen-typescript-from-tolk';
 
-### Configuring TypeScript output
+const abi: ContractABI = getAbiFromSomewhereElse();
+const wrapperSource = generateTypeScriptFileForContract(abi);
+```
 
-1. All structs/aliases/enums are generated to the output — it's unconfigurable currently. 
-If a struct can't be serialized (contains `int` for example, not int32/uint64),
-its `fromSlice` and `store` just contain `throw new Error` with a description.
+The generator expects ABI that already contains the contract metadata needed for wrapper emission, including `codeBoc64`.
 
-2. Default values of all structs are preserved:
-```
-struct WalletStorage {
-    jettonBalance: coins = 0    // <----
-    ownerAddress: address
-    minterAddress: address
-}
-```
+Generated wrappers import `@ton/core`, so the project that uses the generated wrapper file should have `@ton/core` installed.
+
+## CLI usage
 
-Then, `jettonBalance` key in `WalletStorage.create()` will be optional. If it's a storage or a message, it will also be optional in `fromStorage` and `sendXXX`.
+Print wrapper code to `stdout`:
 
-3. If your storage change shape after initialization (the case of NFT), you can specify an "uninited storage" shape:
+```bash
+npx gen-typescript-from-tolk '{"contractName":"MyContract","declarations":[],"storage":{},"incomingMessages":[],"incomingExternal":[],"outgoingMessages":[],"emittedEvents":[],"getMethods":[],"thrownErrors":[],"compilerName":"tolk","compilerVersion":"dev","codeBoc64":"te6ccgEBAQEAAgAAAA=="}'
 ```
-type NOT_INITIALIZED_STORAGE = StorageStructNotInitialized
+
+Write to a file:
+
+```bash
+npx gen-typescript-from-tolk '{"contractName":"MyContract","declarations":[],"storage":{},"incomingMessages":[],"incomingExternal":[],"outgoingMessages":[],"emittedEvents":[],"getMethods":[],"thrownErrors":[],"compilerName":"tolk","compilerVersion":"dev","codeBoc64":"te6ccgEBAQEAAgAAAA=="}' --out ./MyContract.ts
 ```
 
-Then, `fromStorage` will accept fields from this struct, not from `STORAGE`.
+You can also pass `-` instead of JSON to read ABI JSON from `stdin`.
 
+## Development
+
+```bash
+npm run build
+npm test
+npm pack --dry-run
+```
 
-### Known issues
+Local tests and dev scripts compile `.tolk` files through `@ton/tolk-js`, but that compiler is intentionally not part of the published runtime package.
 
-1. Generics behave incorrectly when `T` is used inside unions (because generics are not monomorphic, they are true TypeScript generics). For example, you have `struct A<T> { v: T | int8 }` and instantiate `A<int2 | int4>`, then an actual prefix tree will be '00/01/10', but a TS wrapper serializes '0+T/1'; or, for `A<int8>` actually will be no union (`int8 | int8` = `int8`), but a TS wrapper will still serialize as '0+int8/1'. Similar corner cases appear in get methods that work via the stack. For example, `struct MyNullable<T> { v: T? }`, instantiated as `MyNullable<Point>` has no information about stack layout and type-id.
-2. Non-standard keys for maps are unsupported, like `map<Point, ...>`. Only intN/uintN/address are supported (99% use cases). Others can not be represented via `@ton/core` library at all.
-3. Custom serializers for generic structs `fun Some<T>.packToBuilder` not supported (works perfectly for non-generic structs and aliases, but not for generic).
-4. Default values for struct fields, if a field contains a union, not supported.
+Only `dist/` and `README.md` are included in the published npm package.

package/dist/abi-types.d.ts

@@ -0,0 +1,169 @@
+type bigint_as_string = string;
+export type Ty = {
+    kind: 'int';
+} | {
+    kind: 'intN';
+    n: number;
+} | {
+    kind: 'uintN';
+    n: number;
+} | {
+    kind: 'varintN';
+    n: number;
+} | {
+    kind: 'varuintN';
+    n: number;
+} | {
+    kind: 'coins';
+} | {
+    kind: 'bool';
+} | {
+    kind: 'cell';
+} | {
+    kind: 'builder';
+} | {
+    kind: 'slice';
+} | {
+    kind: 'string';
+} | {
+    kind: 'remaining';
+} | {
+    kind: 'address';
+} | {
+    kind: 'addressOpt';
+} | {
+    kind: 'addressExt';
+} | {
+    kind: 'addressAny';
+} | {
+    kind: 'bitsN';
+    n: number;
+} | {
+    kind: 'nullLiteral';
+} | {
+    kind: 'callable';
+} | {
+    kind: 'void';
+} | {
+    kind: 'unknown';
+} | {
+    kind: 'nullable';
+    inner: Ty;
+    stack_type_id?: number;
+    stack_width?: number;
+} | {
+    kind: 'cellOf';
+    inner: Ty;
+} | {
+    kind: 'arrayOf';
+    inner: Ty;
+} | {
+    kind: 'lispListOf';
+    inner: Ty;
+} | {
+    kind: 'tensor';
+    items: Ty[];
+} | {
+    kind: 'shapedTuple';
+    items: Ty[];
+} | {
+    kind: 'mapKV';
+    k: Ty;
+    v: Ty;
+} | {
+    kind: 'EnumRef';
+    enum_name: string;
+} | {
+    kind: 'StructRef';
+    struct_name: string;
+    type_args?: Ty[];
+} | {
+    kind: 'AliasRef';
+    alias_name: string;
+    type_args?: Ty[];
+} | {
+    kind: 'genericT';
+    name_t: string;
+} | {
+    kind: 'union';
+    variants: UnionVariant[];
+    stack_width: number;
+};
+export interface UnionVariant {
+    variant_ty: Ty;
+    prefix_str: string;
+    prefix_len: number;
+    is_prefix_implicit?: boolean;
+    stack_type_id: number;
+    stack_width: number;
+}
+export type ABIConstExpression = {
+    kind: 'int';
+    v: bigint_as_string;
+} | {
+    kind: 'bool';
+    v: boolean;
+} | {
+    kind: 'slice';
+    hex: string;
+} | {
+    kind: 'string';
+    str: string;
+} | {
+    kind: 'address';
+    addr: string;
+} | {
+    kind: 'tensor';
+    items: ABIConstExpression[];
+} | {
+    kind: 'shapedTuple';
+    items: ABIConstExpression[];
+} | {
+    kind: 'object';
+    struct_name: string;
+    fields: ABIConstExpression[];
+} | {
+    kind: 'castTo';
+    inner: ABIConstExpression;
+    cast_to: Ty;
+} | {
+    kind: 'null';
+};
+export interface ABICustomSerializers {
+    pack_to_builder: boolean;
+    unpack_from_slice: boolean;
+}
+export interface ABIStruct {
+    kind: 'struct';
+    name: string;
+    type_params?: string[];
+    prefix?: {
+        prefix_str: string;
+        prefix_len: number;
+    };
+    fields: {
+        name: string;
+        ty: Ty;
+        default_value?: ABIConstExpression;
+        description?: string;
+    }[];
+    custom_pack_unpack?: ABICustomSerializers;
+}
+export interface ABIAlias {
+    kind: 'alias';
+    name: string;
+    target_ty: Ty;
+    type_params?: string[];
+    custom_pack_unpack?: ABICustomSerializers;
+}
+export interface ABIEnum {
+    kind: 'enum';
+    name: string;
+    encoded_as: Ty;
+    members: {
+        name: string;
+        value: bigint_as_string;
+    }[];
+    custom_pack_unpack?: ABICustomSerializers;
+}
+export {};

package/dist/abi-types.js

@@ -0,0 +1,8 @@
+"use strict";
+/*
+    ABI Types — describes the type system and symbols definitions in the Tolk language.
+    The goal is to have a full bidirectional mapping from any Tolk struct to ABI:
+  all tricky types like generics, aliases, inline unions, etc. should be supported.
+  Then, any input could be packed to a cell and unpacked back — exactly as it's done by the compiler.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/abi.d.ts

@@ -0,0 +1,54 @@
+import { Ty, ABIStruct, ABIAlias, ABIEnum, ABIConstExpression } from './abi-types';
+export interface ABIGetMethod {
+    tvm_method_id: number;
+    name: string;
+    parameters: {
+        name: string;
+        ty: Ty;
+        description?: string;
+        default_value?: ABIConstExpression;
+    }[];
+    return_ty: Ty;
+    description?: string;
+}
+export interface ABIInternalMessage {
+    body_ty: Ty;
+    description?: string;
+    minimal_msg_value?: number;
+    preferred_send_mode?: number;
+}
+export interface ABIExternalMessage {
+    body_ty: Ty;
+    description?: string;
+}
+export interface ABIOutgoingMessage {
+    body_ty: Ty;
+    description?: string;
+}
+export interface ABIStorage {
+    storage_ty?: Ty;
+    storage_at_deployment_ty?: Ty;
+}
+export interface ABIThrownError {
+    kind: 'plain_int' | 'constant' | 'enum_member';
+    name?: string;
+    description?: string;
+    err_code: number;
+}
+export interface ContractABI {
+    contract_name: string;
+    author?: string;
+    version?: string;
+    description?: string;
+    declarations: (ABIStruct | ABIAlias | ABIEnum)[];
+    storage: ABIStorage;
+    incoming_messages: ABIInternalMessage[];
+    incoming_external: ABIExternalMessage[];
+    outgoing_messages: ABIOutgoingMessage[];
+    emitted_events: ABIOutgoingMessage[];
+    get_methods: ABIGetMethod[];
+    thrown_errors: ABIThrownError[];
+    compiler_name: string;
+    compiler_version: string;
+    codeBoc64: string;
+}

package/dist/abi.js

@@ -0,0 +1,13 @@
+"use strict";
+/*
+    ABI of a contract describes how the contract is "seen" by external observers:
+  its get methods, incoming messages, etc.
+    Given an ABI, it becomes possible to
+    - post messages from a client, since ABI provides sufficient info for serialization
+    - generate wrappers for TypeScript and other languages
+    - render its storage in the explorer
+    - create a UI to interact with a contract from Web/IDE
+    - etc.
+    The ABI is emitted by the Tolk compiler, along with bytecode.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCli(argv: string[]): void;

package/dist/cli.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const fs_1 = __importDefault(require("fs"));
+const generate_ts_wrappers_1 = require("./generate-ts-wrappers");
+function printHelp() {
+    const help = [
+        `Usage:`,
+        `  gen-typescript-from-tolk '{"contract_name":"MyContract",...}' --out ./MyContract.ts`,
+        `Options:`,
+        `  --out — output file name; if missing, stdout is used`
+    ].join('\n');
+    process.stdout.write(`${help}\n`);
+}
+function parseArgs(argv) {
+    const args = [...argv];
+    const options = { showHelp: false };
+    while (args.length > 0) {
+        const arg = args.shift();
+        if (arg === '--help' || arg === '-h') {
+            options.showHelp = true;
+            continue;
+        }
+        if (arg === '--out') {
+            const outFile = args.shift();
+            if (!outFile) {
+                throw new Error("Missing value for '--out'");
+            }
+            options.outFile = outFile;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown option '${arg}'`);
+        }
+        if (options.abiJsonArg !== undefined) {
+            throw new Error('Only one ABI JSON argument is expected');
+        }
+        options.abiJsonArg = arg;
+    }
+    return options;
+}
+function parseAbiJson(rawJson) {
+    try {
+        return JSON.parse(rawJson);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ABI JSON: ${error.message || error}`);
+    }
+}
+function writeOutput(output, outFile) {
+    if (outFile) {
+        fs_1.default.writeFileSync(outFile, output, 'utf-8');
+        process.stdout.write(`written ${outFile}\n`);
+        return;
+    }
+    process.stdout.write(output);
+}
+function runCli(argv) {
+    const options = parseArgs(argv);
+    if (options.showHelp) {
+        printHelp();
+        return;
+    }
+    if (!options.abiJsonArg) {
+        throw new Error("ABI JSON argument is required");
+    }
+    const abi = parseAbiJson(options.abiJsonArg);
+    const generated = (0, generate_ts_wrappers_1.generateTypeScriptFileForContract)(abi);
+    writeOutput(generated, options.outFile);
+}
+if (require.main === module) {
+    try {
+        runCli(process.argv.slice(2));
+    }
+    catch (ex) {
+        process.stderr.write(`${ex.message || ex}\n`);
+        process.exitCode = 1;
+    }
+}

package/dist/codegen-ctx.d.ts

@@ -0,0 +1,66 @@
+import type { Ty, ABIStruct, ABIAlias, ABIEnum } from './abi-types';
+export declare const RUNTIME: {
+    beginCell: string;
+    lookupPrefix: string;
+    lookupPrefixAndEat: string;
+    throwNonePrefixMatch: string;
+    loadAndCheckPrefix32: string;
+    loadAndCheckPrefix: string;
+    loadTolkBitsN: string;
+    storeTolkBitsN: string;
+    loadTolkAddressAny: string;
+    storeTolkAddressAny: string;
+    loadTolkRemaining: string;
+    storeTolkRemaining: string;
+    loadCellRef: string;
+    storeCellRef: string;
+    loadArrayOf: string;
+    storeArrayOf: string;
+    loadLispListOf: string;
+    storeLispListOf: string;
+    storeTolkNullable: string;
+    makeCellFrom: string;
+    createDictionaryValue: string;
+    registerCustomPackUnpack: string;
+    ExtraSendOptions: string;
+    StackReader: string;
+};
+export declare class SymTable {
+    private structs;
+    private aliases;
+    private enums;
+    constructor(declarations: (ABIStruct | ABIAlias | ABIEnum)[]);
+    getStruct(structName: string): ABIStruct;
+    getAlias(aliasName: string): ABIAlias;
+    getEnum(enumName: string): ABIEnum;
+    getAliasTarget(aliasName: string): Ty;
+}
+export declare class CodegenCtx {
+    readonly symbols: SymTable;
+    intNOccurred: Set<string>;
+    uintNOccurred: Set<string>;
+    varIntNOccurred: Set<string>;
+    bitsNOccurred: Set<string>;
+    has_RemainingBitsAndRefs: boolean;
+    has_customPackUnpack: boolean;
+    has_customDictV: boolean;
+    has_implicitUnionPrefix: boolean;
+    has_non32Prefixes: boolean;
+    has_addressAny: boolean;
+    has_arrayOf: boolean;
+    has_lispListOf: boolean;
+    stackReadsUnknown: boolean;
+    stackReadsArrayOf: boolean;
+    stackReadsLispListOf: boolean;
+    stackReadsSnakeString: boolean;
+    stackReadsTuple: boolean;
+    stackReadsMapKV: boolean;
+    stackReadsBuilder: boolean;
+    stackReadsNullable: boolean;
+    stackReadsWideNullable: boolean;
+    stackReadsUnionType: boolean;
+    stackReadsCellRef: boolean;
+    stackReadsNullLiteral: boolean;
+    constructor(declarations: (ABIStruct | ABIAlias | ABIEnum)[]);
+    sortOccurred(occurred: Set<string>): string[];
+}

package/dist/codegen-ctx.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodegenCtx = exports.SymTable = exports.RUNTIME = void 0;
+const unsupported_errors_1 = require("./unsupported-errors");
+// Functions implemented in an output template, used to detect name shadowing.
+exports.RUNTIME = {
+    beginCell: 'beginCell',
+    lookupPrefix: 'lookupPrefix',
+    lookupPrefixAndEat: 'lookupPrefixAndEat',
+    throwNonePrefixMatch: 'throwNonePrefixMatch',
+    loadAndCheckPrefix32: 'loadAndCheckPrefix32',
+    loadAndCheckPrefix: 'loadAndCheckPrefix',
+    loadTolkBitsN: 'loadTolkBitsN',
+    storeTolkBitsN: 'storeTolkBitsN',
+    loadTolkAddressAny: 'loadTolkAddressAny',
+    storeTolkAddressAny: 'storeTolkAddressAny',
+    loadTolkRemaining: 'loadTolkRemaining',
+    storeTolkRemaining: 'storeTolkRemaining',
+    loadCellRef: 'loadCellRef',
+    storeCellRef: 'storeCellRef',
+    loadArrayOf: 'loadArrayOf',
+    storeArrayOf: 'storeArrayOf',
+    loadLispListOf: 'loadLispListOf',
+    storeLispListOf: 'storeLispListOf',
+    storeTolkNullable: 'storeTolkNullable',
+    makeCellFrom: 'makeCellFrom',
+    createDictionaryValue: 'createDictionaryValue',
+    registerCustomPackUnpack: 'registerCustomPackUnpack',
+    ExtraSendOptions: 'ExtraSendOptions',
+    StackReader: 'StackReader',
+};
+// SymTable is an index of top-level declarations.
+class SymTable {
+    constructor(declarations) {
+        this.structs = new Map();
+        this.aliases = new Map();
+        this.enums = new Map();
+        for (const n of declarations) {
+            if (n.kind === 'struct')
+                this.structs.set(n.name, n);
+            else if (n.kind === 'alias')
+                this.aliases.set(n.name, n);
+            else if (n.kind === 'enum')
+                this.enums.set(n.name, n);
+        }
+    }
+    getStruct(structName) {
+        const s = this.structs.get(structName);
+        if (s === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('struct', structName);
+        return s;
+    }
+    getAlias(aliasName) {
+        const a = this.aliases.get(aliasName);
+        if (a === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('alias', aliasName);
+        return a;
+    }
+    getEnum(enumName) {
+        const e = this.enums.get(enumName);
+        if (e === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('enum', enumName);
+        return e;
+    }
+    getAliasTarget(aliasName) {
+        return this.getAlias(aliasName).target_ty;
+    }
+}
+exports.SymTable = SymTable;
+// CodegenCtx represents current state of TypeScript code generation.
+// It contains properties that affect final output and help resolve symbols.
+// For example, we want Tolk `int64` not be just TS `bigint`, but
+// to export `type int64 = bigint` and use `int64` directly,
+// that's why we track all occurred intN.
+// Same for other public properties, they are modified while iterating through declarations.
+class CodegenCtx {
+    constructor(declarations) {
+        this.intNOccurred = new Set(['int8', 'int16', 'int32', 'int256']);
+        this.uintNOccurred = new Set(['uint8', 'uint16', 'uint32', 'uint256']);
+        this.varIntNOccurred = new Set();
+        this.bitsNOccurred = new Set();
+        this.has_RemainingBitsAndRefs = false;
+        this.has_customPackUnpack = false;
+        this.has_customDictV = false;
+        this.has_implicitUnionPrefix = false;
+        this.has_non32Prefixes = false;
+        this.has_addressAny = false;
+        this.has_arrayOf = false;
+        this.has_lispListOf = false;
+        this.stackReadsUnknown = false;
+        this.stackReadsArrayOf = false;
+        this.stackReadsLispListOf = false;
+        this.stackReadsSnakeString = false;
+        this.stackReadsTuple = false;
+        this.stackReadsMapKV = false;
+        this.stackReadsBuilder = false;
+        this.stackReadsNullable = false;
+        this.stackReadsWideNullable = false;
+        this.stackReadsUnionType = false;
+        this.stackReadsCellRef = false;
+        this.stackReadsNullLiteral = false;
+        this.symbols = new SymTable(declarations);
+    }
+    sortOccurred(occurred) {
+        return [...occurred].sort((a, b) => a.length - b.length || a.localeCompare(b));
+    }
+}
+exports.CodegenCtx = CodegenCtx;

package/dist/emit-field-defs.d.ts

@@ -0,0 +1,5 @@
+import { ABIConstExpression, Ty } from './abi-types';
+import { CodegenCtx } from './codegen-ctx';
+export declare function isDefaultValueSupported(fieldTy: Ty): boolean;
+export declare function emitFieldDefault(ctx: CodegenCtx, expr: ABIConstExpression): string;
+export declare function emitFieldDefaultInComment(expr: ABIConstExpression): string;

package/dist/emit-field-defs.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefaultValueSupported = isDefaultValueSupported;
+exports.emitFieldDefault = emitFieldDefault;
+exports.emitFieldDefaultInComment = emitFieldDefaultInComment;
+const formatting_1 = require("./formatting");
+const types_kernel_1 = require("./types-kernel");
+// Default values of struct fields are also exported to TypeScript unless they are hard to be represented.
+// In practice, all simple values are okay: `f: int = 5`, `f: coins = ton("1")`, etc.
+// But in theory, a field can be a union, for example. It will require a large amount of work to support
+// cases like `f: int8 | slice = 5` or `f: int32 | int64 = 5 as int64` (to generate correct `$` labels).
+// So, if such a field exists, then we just assume it has no default.
+function isDefaultValueSupported(fieldTy) {
+    if (fieldTy.kind === 'arrayOf')
+        return isDefaultValueSupported(fieldTy.inner);
+    if (fieldTy.kind === 'lispListOf')
+        return isDefaultValueSupported(fieldTy.inner);
+    if (fieldTy.kind === 'tensor')
+        return fieldTy.items.every(isDefaultValueSupported);
+    if (fieldTy.kind === 'shapedTuple')
+        return fieldTy.items.every(isDefaultValueSupported);
+    return fieldTy.kind !== 'union' && fieldTy.kind !== 'mapKV';
+}
+// Default values of fields (particularly, in storage) are precalculated by the compiler
+// and stored as "const expression" intermediate representation in ABI.
+// Here we output them to a valid TypeScript expression.
+// Default parameters for get methods follow the same logic, they are also "const expressions".
+function emitFieldDefault(ctx, expr) {
+    switch (expr.kind) {
+        case 'int': return expr.v + 'n';
+        case 'bool': return expr.v ? 'true' : 'false';
+        case 'slice': return `new c.Slice(new c.BitReader(new c.BitString(Buffer.from('${expr.hex}', 'hex'), 0, ${expr.hex.length * 4})), [])`;
+        case 'string': return JSON.stringify(expr.str);
+        case 'address': return `c.Address.parse('${expr.addr}')`;
+        case 'tensor': return `[${expr.items.map(i => emitFieldDefault(ctx, i)).join(', ')}]`;
+        case 'shapedTuple': return `[${expr.items.map(i => emitFieldDefault(ctx, i)).join(', ')}]`;
+        case 'object': {
+            const structRef = ctx.symbols.getStruct(expr.struct_name);
+            return `{ $: '${structRef.name}', ${[...structRef.fields.map((f, i) => `${(0, formatting_1.safeFieldDecl)(f.name)}: ${emitFieldDefault(ctx, expr.fields[i])}`)].join(', ')} }`;
+        }
+        case 'castTo': return emitFieldDefault(ctx, expr.inner);
+        case 'null': return `null`;
+    }
+}
+// Output a default value not as a TypeScript expression, but as a human-readable one.
+// For instance, "123" instead of bigint "123n".
+// It's inserted inside comments next to fields having defaults.
+function emitFieldDefaultInComment(expr) {
+    switch (expr.kind) {
+        case 'int': return expr.v;
+        case 'bool': return expr.v ? 'true' : 'false';
+        case 'slice': return `hex('${expr.hex}')`;
+        case 'string': return JSON.stringify(expr.str);
+        case 'address': return `address('${expr.addr}')`;
+        case 'tensor': return `[${expr.items.map(emitFieldDefaultInComment).join(', ')}]`;
+        case 'shapedTuple': return `[${expr.items.map(emitFieldDefaultInComment).join(', ')}]`;
+        case 'object': return `${expr.struct_name} { ${expr.fields.map(emitFieldDefaultInComment).join(', ')} }`;
+        case 'castTo': return `${emitFieldDefaultInComment(expr.inner)} as ${(0, types_kernel_1.renderTy)(expr.cast_to)}`;
+        case 'null': return `null`;
+    }
+}

package/dist/emit-pack-unpack.d.ts

@@ -0,0 +1,9 @@
+import type { Ty } from './abi-types';
+import { CodegenCtx } from './codegen-ctx';
+export declare function emitLoadExpr(ctx: CodegenCtx, fieldPath: string, ty: Ty): string;
+export declare function emitLoadCallback(ctx: CodegenCtx, fieldPath: string, ty: Ty): string;
+export declare function emitStoreStatement(ctx: CodegenCtx, tsExpr: string, ty: Ty): string;
+export declare function emitStoreCallback(ctx: CodegenCtx, ty: Ty): string;
+export declare function emitMakeCellFromExpr(ctx: CodegenCtx, tsExpr: string, ty: Ty, disableShortHand?: boolean): string;
+export declare function emitCallToCreateMethodExpr(ctx: CodegenCtx, bodyArg: string, ty: Ty): string;
+export declare function emitDictKVSerializers(ctx: CodegenCtx, fieldPath: string, tyK: Ty, tyV: Ty): string;