gen-typescript-from-tolk-dev 0.2.4 → 0.3.0

package/README.md

@@ -18,7 +18,7 @@ const abi: ContractABI = getAbiFromSomewhereElse();
 const wrapperSource = generateTypeScriptFileForContract(abi);
 ```
 
-The generator expects ABI that already contains the contract metadata needed for wrapper emission, including `codeBoc64`.
+The generator expects ABI that already contains the contract metadata needed for wrapper emission, including `code_boc64`.
 
 Generated wrappers import `@ton/core`, so the project that uses the generated wrapper file should have `@ton/core` installed.
 
@@ -27,17 +27,37 @@ Generated wrappers import `@ton/core`, so the project that uses the generated wr
 Print wrapper code to `stdout`:
 
 ```bash
-npx gen-typescript-from-tolk '{"contractName":"MyContract","declarations":[],"storage":{},"incomingMessages":[],"incomingExternal":[],"outgoingMessages":[],"emittedEvents":[],"getMethods":[],"thrownErrors":[],"compilerName":"tolk","compilerVersion":"dev","codeBoc64":"te6ccgEBAQEAAgAAAA=="}'
+npx gen-typescript-from-tolk '{"contract_name":"MyContract","unique_types":[...], ..., "compiler_version":"1.4.0","code_boc64":"te6ccgEBAQEAAgAAAA=="}'
 ```
 
 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
+npx gen-typescript-from-tolk '<abi-json-with-code_boc64>' --out ./MyContract.gen.ts
 ```
 
 You can also pass `-` instead of JSON to read ABI JSON from `stdin`.
 
+## Known limitations
+
+### Generic structs whose unions reshape after monomorphization
+
+When generic `T` is inside a union, substituting concrete type arguments may collapse or expand the union's variants.
+The instantiated type then no longer matches what you'd get by naive substitution.
+
+```tolk
+struct WithFallback<T> {
+    field: T | int32
+}
+```
+
+The following corner cases would not work, because wrappers for TS `interface WithFallback<T>` assume `field` to be a union of two:
+
+- `WithFallback<int32>` — field collapses to `int32`.
+- `WithFallback<bool | int8>` — field becomes `bool | int8 | int32`.
+
+In practice, such cases never occur.
+
 ## Development
 
 ```bash

package/dist/abi-types.d.ts

@@ -48,54 +48,54 @@ export type Ty = {
     kind: 'unknown';
 } | {
     kind: 'nullable';
-    inner: Ty;
+    inner_ty_idx: number;
     stack_type_id?: number;
     stack_width?: number;
 } | {
     kind: 'cellOf';
-    inner: Ty;
+    inner_ty_idx: number;
 } | {
     kind: 'arrayOf';
-    inner: Ty;
+    inner_ty_idx: number;
 } | {
     kind: 'lispListOf';
-    inner: Ty;
+    inner_ty_idx: number;
 } | {
     kind: 'tensor';
-    items: Ty[];
+    items_ty_idx: number[];
 } | {
     kind: 'shapedTuple';
-    items: Ty[];
+    items_ty_idx: number[];
 } | {
     kind: 'mapKV';
-    k: Ty;
-    v: Ty;
+    key_ty_idx: number;
+    value_ty_idx: number;
 } | {
     kind: 'EnumRef';
     enum_name: string;
 } | {
     kind: 'StructRef';
     struct_name: string;
-    type_args?: Ty[];
+    type_args_ty_idx?: number[];
 } | {
     kind: 'AliasRef';
     alias_name: string;
-    type_args?: Ty[];
+    type_args_ty_idx?: number[];
 } | {
     kind: 'genericT';
     name_t: string;
 } | {
     kind: 'union';
     variants: UnionVariant[];
-    stack_width: number;
+    stack_width?: number;
 };
 export interface UnionVariant {
-    variant_ty: Ty;
-    prefix_str: string;
+    variant_ty_idx: number;
+    prefix_num: number;
     prefix_len: number;
     is_prefix_implicit?: boolean;
-    stack_type_id: number;
-    stack_width: number;
+    stack_type_id?: number;
+    stack_width?: number;
 }
 export type ABIConstExpression = {
     kind: 'int';
@@ -125,7 +125,7 @@ export type ABIConstExpression = {
 } | {
     kind: 'castTo';
     inner: ABIConstExpression;
-    cast_to: Ty;
+    cast_to_ty_idx: number;
 } | {
     kind: 'null';
 };
@@ -136,14 +136,15 @@ export interface ABICustomSerializers {
 export interface ABIStruct {
     kind: 'struct';
     name: string;
+    ty_idx: number;
     type_params?: string[];
     prefix?: {
-        prefix_str: string;
+        prefix_num: number;
         prefix_len: number;
     };
     fields: {
         name: string;
-        ty: Ty;
+        ty_idx: number;
         default_value?: ABIConstExpression;
         description?: string;
     }[];
@@ -152,18 +153,30 @@ export interface ABIStruct {
 export interface ABIAlias {
     kind: 'alias';
     name: string;
-    target_ty: Ty;
+    ty_idx: number;
+    target_ty_idx: number;
     type_params?: string[];
     custom_pack_unpack?: ABICustomSerializers;
 }
 export interface ABIEnum {
     kind: 'enum';
     name: string;
-    encoded_as: Ty;
+    ty_idx: number;
+    encoded_as_ty_idx: number;
     members: {
         name: string;
         value: bigint_as_string;
     }[];
     custom_pack_unpack?: ABICustomSerializers;
 }
+export interface ABIStructInstantiation {
+    ty_idx: number;
+    struct_name: string;
+    monomorphic_fields_ty_idx: number[];
+}
+export interface ABIAliasInstantiation {
+    ty_idx: number;
+    alias_name: string;
+    monomorphic_target_ty_idx: number;
+}
 export {};

package/dist/abi.d.ts

@@ -1,33 +1,32 @@
-import { Ty, ABIStruct, ABIAlias, ABIEnum, ABIConstExpression } from './abi-types';
+import { Ty, ABIStruct, ABIAlias, ABIEnum, ABIConstExpression, ABIStructInstantiation, ABIAliasInstantiation } from './abi-types';
 export interface ABIGetMethod {
     tvm_method_id: number;
     name: string;
     parameters: {
         name: string;
-        ty: Ty;
+        ty_idx: number;
         description?: string;
         default_value?: ABIConstExpression;
     }[];
-    return_ty: Ty;
+    return_ty_idx: number;
     description?: string;
 }
 export interface ABIInternalMessage {
-    body_ty: Ty;
+    body_ty_idx: number;
     description?: string;
-    minimal_msg_value?: number;
-    preferred_send_mode?: number;
 }
 export interface ABIExternalMessage {
-    body_ty: Ty;
+    body_ty_idx: number;
     description?: string;
 }
 export interface ABIOutgoingMessage {
-    body_ty: Ty;
+    body_ty_idx: number;
     description?: string;
 }
 export interface ABIStorage {
-    storage_ty?: Ty;
-    storage_at_deployment_ty?: Ty;
+    storage_ty_idx?: number;
+    storage_at_deployment_ty_idx?: number;
+    description?: string;
 }
 export interface ABIThrownError {
     kind: 'plain_int' | 'constant' | 'enum_member';
@@ -40,6 +39,9 @@ export interface ContractABI {
     author?: string;
     version?: string;
     description?: string;
+    unique_types: Ty[];
+    struct_instantiations: ABIStructInstantiation[];
+    alias_instantiations: ABIAliasInstantiation[];
     declarations: (ABIStruct | ABIAlias | ABIEnum)[];
     storage: ABIStorage;
     incoming_messages: ABIInternalMessage[];
@@ -50,5 +52,4 @@ export interface ContractABI {
     thrown_errors: ABIThrownError[];
     compiler_name: string;
     compiler_version: string;
-    codeBoc64: string;
 }

package/dist/codegen-ctx.d.ts

@@ -1,4 +1,5 @@
-import type { Ty, ABIStruct, ABIAlias, ABIEnum } from './abi-types';
+import type { ContractABI } from './abi';
+import { SymTable } from './types-kernel';
 export declare const RUNTIME: {
     beginCell: string;
     lookupPrefix: string;
@@ -25,16 +26,6 @@ export declare const RUNTIME: {
     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>;
@@ -61,6 +52,6 @@ export declare class CodegenCtx {
     stackReadsUnionType: boolean;
     stackReadsCellRef: boolean;
     stackReadsNullLiteral: boolean;
-    constructor(declarations: (ABIStruct | ABIAlias | ABIEnum)[]);
+    constructor(abi: ContractABI);
     sortOccurred(occurred: Set<string>): string[];
 }

package/dist/codegen-ctx.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodegenCtx = exports.SymTable = exports.RUNTIME = void 0;
-const unsupported_errors_1 = require("./unsupported-errors");
+exports.CodegenCtx = exports.RUNTIME = void 0;
+const types_kernel_1 = require("./types-kernel");
 // Functions implemented in an output template, used to detect name shadowing.
 exports.RUNTIME = {
     beginCell: 'beginCell',
@@ -29,44 +29,6 @@ exports.RUNTIME = {
     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
@@ -74,7 +36,7 @@ exports.SymTable = SymTable;
 // that's why we track all occurred intN.
 // Same for other public properties, they are modified while iterating through declarations.
 class CodegenCtx {
-    constructor(declarations) {
+    constructor(abi) {
         this.intNOccurred = new Set(['int8', 'int16', 'int32', 'int256']);
         this.uintNOccurred = new Set(['uint8', 'uint16', 'uint32', 'uint256']);
         this.varIntNOccurred = new Set();
@@ -99,7 +61,7 @@ class CodegenCtx {
         this.stackReadsUnionType = false;
         this.stackReadsCellRef = false;
         this.stackReadsNullLiteral = false;
-        this.symbols = new SymTable(declarations);
+        this.symbols = new types_kernel_1.SymTable(abi.declarations, abi.unique_types, abi.struct_instantiations, abi.alias_instantiations);
     }
     sortOccurred(occurred) {
         return [...occurred].sort((a, b) => a.length - b.length || a.localeCompare(b));

package/dist/dynamic-ctx.d.ts

@@ -1,6 +1,6 @@
 import * as c from '@ton/core';
-import { SymTable } from './codegen-ctx';
 import { ABIGetMethod, ContractABI } from './abi';
+import { SymTable } from './types-kernel';
 type CustomPackToBuilderFn<T> = (self: T, b: c.Builder) => void;
 type CustomUnpackFromSliceFn<T> = (s: c.Slice) => T;
 export declare class DynamicCtx {
@@ -8,7 +8,7 @@ export declare class DynamicCtx {
     readonly getMethods: ABIGetMethod[];
     readonly symbols: SymTable;
     private customSerializersRegistry;
-    constructor(contract: ContractABI);
+    constructor(abi: ContractABI);
     registerCustomPackUnpack<T>(typeName: string, packToBuilderFn: CustomPackToBuilderFn<T> | null, unpackFromSliceFn: CustomUnpackFromSliceFn<T> | null): void;
     getCustomPackFnOrThrow(typeName: string, fieldPath: string): CustomPackToBuilderFn<any>;
     getCustomUnpackFnOrThrow(typeName: string, fieldPath: string): CustomUnpackFromSliceFn<any>;

package/dist/dynamic-ctx.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicCtx = void 0;
-const codegen_ctx_1 = require("./codegen-ctx");
 const unsupported_errors_1 = require("./unsupported-errors");
+const types_kernel_1 = require("./types-kernel");
 class DynamicCtx {
-    constructor(contract) {
+    constructor(abi) {
         this.customSerializersRegistry = new Map;
-        this.contractName = contract.contract_name;
-        this.getMethods = contract.get_methods;
-        this.symbols = new codegen_ctx_1.SymTable(contract.declarations);
+        this.contractName = abi.contract_name;
+        this.getMethods = abi.get_methods;
+        this.symbols = new types_kernel_1.SymTable(abi.declarations, abi.unique_types, abi.struct_instantiations, abi.alias_instantiations);
     }
     registerCustomPackUnpack(typeName, packToBuilderFn, unpackFromSliceFn) {
         if (this.customSerializersRegistry.has(typeName)) {

package/dist/dynamic-debug-print.d.ts

@@ -1,9 +1,8 @@
 import { DynamicCtx } from './dynamic-ctx';
-import { Ty } from './abi-types';
 import { StackReader } from './dynamic-get-methods';
 /**
  * Read a value of type `ty` from the TVM stack `tuple` and return a human-readable string.
  * Consumes `calcWidthOnStack(ty)` elements from the beginning of the array.
  * Example: given `Point { x: int, y: int }` and stack `[10n, 20n]`, returns "Point { x: 10, y: 20 }".
  */
-export declare function debugPrintFromStack(ctx: DynamicCtx, r: StackReader, ty: Ty): string;
+export declare function debugPrintFromStack(ctx: DynamicCtx, r: StackReader, tyIdx: number): string;

package/dist/dynamic-debug-print.js

@@ -16,13 +16,14 @@ function printRawCellContents(c) {
 }
 // Read `ty` from a stack and return formatted human-readable representation.
 // Throws if a stack is too small or failed to deserialize a value (inside `Cell<T>` or a map, for example).
-function debugFormat(ctx, r, fieldPath, ty, unTupleIfW = false) {
+function debugFormat(ctx, r, fieldPath, tyIdx, unTupleIfW = false) {
     if (unTupleIfW) {
-        let wOnStack = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, ty);
+        let wOnStack = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, tyIdx);
         if (wOnStack !== 1) {
-            return r.readTuple(wOnStack, (r) => debugFormat(ctx, r, fieldPath, ty, false));
+            return r.readTuple(wOnStack, (r) => debugFormat(ctx, r, fieldPath, tyIdx, false));
         }
     }
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'int':
         case 'intN':
@@ -38,10 +39,10 @@ function debugFormat(ctx, r, fieldPath, ty, unTupleIfW = false) {
         case 'remaining': return `slice{${printRawCellContents(r.readSlice().asCell())}}`;
         case 'string': return `"${r.readSnakeString()}"`;
         case 'address': return r.readSlice().loadAddress().toString();
-        case 'addressOpt': return debugFormat(ctx, r, fieldPath, { kind: 'nullable', inner: { kind: 'address' } });
+        case 'addressOpt': return r.readNullable((r) => r.readSlice().loadAddress().toString()) ?? 'null';
         case 'addressExt': return r.readSlice().loadExternalAddress().toString();
         case 'addressAny': {
-            let addr = (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, ty, r.readSlice());
+            let addr = (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, tyIdx, r.readSlice());
             return addr === 'none' ? 'addr_none' : addr.toString();
         }
         case 'nullLiteral': return r.readNullLiteral() ?? 'null';
@@ -49,48 +50,48 @@ function debugFormat(ctx, r, fieldPath, ty, unTupleIfW = false) {
         case 'unknown': return debugPrintUnknown(r.readUnknown());
         case 'nullable': {
             if (ty.stack_type_id) {
-                return r.readWideNullable(ty.stack_width, (r) => debugFormat(ctx, r, fieldPath, ty.inner)) ?? 'null';
+                return r.readWideNullable(ty.stack_width, (r) => debugFormat(ctx, r, fieldPath, ty.inner_ty_idx)) ?? 'null';
             }
-            return r.readNullable((r) => debugFormat(ctx, r, fieldPath, ty.inner)) ?? 'null';
+            return r.readNullable((r) => debugFormat(ctx, r, fieldPath, ty.inner_ty_idx)) ?? 'null';
         }
         case 'cellOf': {
             let innerStr = r.readCellRef((s) => {
-                const deserialized = (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, ty.inner, s);
-                return debugFormatValue(ctx, fieldPath, ty.inner, deserialized);
+                const deserialized = (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, ty.inner_ty_idx, s);
+                return debugFormatValue(ctx, fieldPath, ty.inner_ty_idx, deserialized);
             });
             return `ref{${innerStr.ref}}`;
         }
         case 'arrayOf': {
-            let items = r.readArrayOf((r) => debugFormat(ctx, r, fieldPath, ty.inner, true));
+            let items = r.readArrayOf((r) => debugFormat(ctx, r, fieldPath, ty.inner_ty_idx, true));
             return `[${items.join(', ')}]`;
         }
         case 'lispListOf': {
-            let items = r.readLispListOf((r) => debugFormat(ctx, r, fieldPath, ty.inner, true));
+            let items = r.readLispListOf((r) => debugFormat(ctx, r, fieldPath, ty.inner_ty_idx, true));
             return `[${items.join(', ')}]`;
         }
         case 'tensor': {
             let parts = [];
-            for (let i = 0; i < ty.items.length; ++i) {
-                parts.push(debugFormat(ctx, r, `${fieldPath}[${i}]`, ty.items[i]));
+            for (let i = 0; i < ty.items_ty_idx.length; ++i) {
+                parts.push(debugFormat(ctx, r, `${fieldPath}[${i}]`, ty.items_ty_idx[i]));
             }
             return `(${parts.join(', ')})`;
         }
         case 'shapedTuple': {
-            return r.readTuple(ty.items.length, (r) => {
+            return r.readTuple(ty.items_ty_idx.length, (r) => {
                 let parts = [];
-                for (let i = 0; i < ty.items.length; ++i) {
-                    parts.push(debugFormat(ctx, r, `${fieldPath}[${i}]`, ty.items[i], true));
+                for (let i = 0; i < ty.items_ty_idx.length; ++i) {
+                    parts.push(debugFormat(ctx, r, `${fieldPath}[${i}]`, ty.items_ty_idx[i], true));
                 }
                 return `[${parts.join(', ')}]`;
             });
         }
         case 'mapKV': {
-            let dictKey = (0, dynamic_serialization_1.createTonCoreDictionaryKey)(fieldPath, ty.k);
-            let dictValue = (0, dynamic_serialization_1.createTonCoreDictionaryValue)(ctx, fieldPath, ty.v);
+            let dictKey = (0, dynamic_serialization_1.createTonCoreDictionaryKey)(ctx, fieldPath, ty.key_ty_idx);
+            let dictValue = (0, dynamic_serialization_1.createTonCoreDictionaryValue)(ctx, fieldPath, ty.value_ty_idx);
             let entries = [];
             for (let [k, v] of r.readDictionary(dictKey, dictValue)) {
-                let kStr = debugFormatValue(ctx, fieldPath, ty.k, k);
-                let vStr = debugFormatValue(ctx, `${fieldPath}[${kStr}]`, ty.v, v);
+                let kStr = debugFormatValue(ctx, fieldPath, ty.key_ty_idx, k);
+                let vStr = debugFormatValue(ctx, `${fieldPath}[${kStr}]`, ty.value_ty_idx, v);
                 entries.push(`${kStr}: ${vStr}`);
             }
             if (entries.length === 0) {
@@ -108,28 +109,29 @@ function debugFormat(ctx, r, fieldPath, ty, unTupleIfW = false) {
             return `${ty.enum_name}(${value})`;
         }
         case 'StructRef': {
-            const structRef = ctx.symbols.getStruct(ty.struct_name);
-            if (structRef.fields.length === 0) {
+            let fields = ctx.symbols.structFieldsOf(tyIdx);
+            if (fields.length === 0) {
                 return `${ty.struct_name} {}`;
             }
             const fieldStrs = [];
-            for (const f of structRef.fields) {
-                const fTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(f.ty, structRef.type_params, ty.type_args) : f.ty;
-                fieldStrs.push(`${f.name}: ${debugFormat(ctx, r, `${fieldPath}.${f.name}`, fTy)}`);
+            for (const f of fields) {
+                fieldStrs.push(`${f.name}: ${debugFormat(ctx, r, `${fieldPath}.${f.name}`, f.ty_idx)}`);
             }
             return `${ty.struct_name} { ${fieldStrs.join(', ')} }`;
         }
         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 debugFormat(ctx, r, fieldPath, targetTy);
+            const target = ctx.symbols.aliasTargetOf(tyIdx);
+            return debugFormat(ctx, r, fieldPath, target.ty_idx);
         }
         case 'union': {
+            if (ty.stack_width === undefined) {
+                throw new Error(`unexpected stack_width=undefined at ${fieldPath}`);
+            }
             const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
             const infoForTypeId = {};
             for (let v of variants) {
                 infoForTypeId[v.stack_type_id] = [v.stack_width, v.hasValueField ? v.labelStr : null,
-                    (r) => debugFormat(ctx, r, `${fieldPath}#${v.labelStr}`, v.variant_ty)
+                    (r) => debugFormat(ctx, r, `${fieldPath}#${v.labelStr}`, v.variant_ty_idx)
                 ];
             }
             // readUnionType returns `valueT` (if no label) or `{ $: "label", value: valueT }`
@@ -152,12 +154,12 @@ function debugFormat(ctx, r, fieldPath, ty, unTupleIfW = false) {
 // Format a value that was already parsed by dynamicUnpack into a JS representation.
 // This is used for inner values of `Cell<T>` and map entries, where we parse via `dynamicUnpack`
 // and then need to show the result as a string.
-function debugFormatValue(ctx, fieldPath, ty, value) {
+function debugFormatValue(ctx, fieldPath, tyIdx, value) {
     // unlike `debugFormat()`, here we don't read `ty` from a stack: we already have `value` of type `ty`;
     // to visualize it, instead of making a giant switch-case for all types, do the following trick:
     // pack value back to a tuple, and render this tuple as if it's a stack value
-    const backToTuple = (0, dynamic_get_methods_1.makeTvmTupleDynamic)(ctx, ty, value);
-    return debugFormat(ctx, new dynamic_get_methods_1.StackReader(backToTuple), fieldPath, ty);
+    const backToTuple = (0, dynamic_get_methods_1.makeTvmTupleDynamic)(ctx, tyIdx, value);
+    return debugFormat(ctx, new dynamic_get_methods_1.StackReader(backToTuple), fieldPath, tyIdx);
 }
 // `unknown` is a raw TVM tuple item; `tuple`, by definition, is `array<unknown>`,
 // it has no compile-time type information, so visualize it anyhow
@@ -178,6 +180,6 @@ function debugPrintUnknown(item) {
  * Consumes `calcWidthOnStack(ty)` elements from the beginning of the array.
  * Example: given `Point { x: int, y: int }` and stack `[10n, 20n]`, returns "Point { x: 10, y: 20 }".
  */
-function debugPrintFromStack(ctx, r, ty) {
-    return debugFormat(ctx, r, 'self', ty);
+function debugPrintFromStack(ctx, r, tyIdx) {
+    return debugFormat(ctx, r, 'self', tyIdx);
 }

package/dist/dynamic-get-methods.d.ts

@@ -1,6 +1,5 @@
 import * as c from '@ton/core';
 import { DynamicCtx } from './dynamic-ctx';
-import { Ty } from './abi-types';
 type LoadCallback<T> = (s: c.Slice) => T;
 export declare class StackReader {
     private tuple;
@@ -32,7 +31,7 @@ export declare class StackReader {
  * Pack any `value` of type `ty` to a TVM tuple.
  * This tuple can be used as a get method argument or debug-printed as human-readable.
  */
-export declare function makeTvmTupleDynamic(ctx: DynamicCtx, ty: Ty, value: any): c.TupleItem[];
+export declare function makeTvmTupleDynamic(ctx: DynamicCtx, tyIdx: number, value: any): c.TupleItem[];
 /**
  * Invoke any get method taking plain JS variables as arguments and interpreting the resulting TVM tuple according to ABI.
  * Example: `get fun intAndPoint(i: int, p: Point): Point`.