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

package/dist/dynamic-debug-print.js

@@ -1,183 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debugPrintFromStack = debugPrintFromStack;
-const dynamic_get_methods_1 = require("./dynamic-get-methods");
-const dynamic_serialization_1 = require("./dynamic-serialization");
-const types_kernel_1 = require("./types-kernel");
-/*
-    Debug printing from the TVM stack.
-    Given TupleItem[] of a type Ty, and an ABI (via DynamicCtx),
-  produce a human-readable string representation.
-    This is used for debugging / println / explorers —
-  to show the value of a variable or a get method result in a readable format.
- */
-function printRawCellContents(c) {
-    return c.toString();
-}
-// 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) {
-    if (unTupleIfW) {
-        let wOnStack = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, ty);
-        if (wOnStack !== 1) {
-            return r.readTuple(wOnStack, (r) => debugFormat(ctx, r, fieldPath, ty, false));
-        }
-    }
-    switch (ty.kind) {
-        case 'int':
-        case 'intN':
-        case 'uintN':
-        case 'varintN':
-        case 'varuintN':
-        case 'coins': return r.readBigInt().toString();
-        case 'bool': return r.readBoolean() ? 'true' : 'false';
-        case 'cell': return `cell{${printRawCellContents(r.readCell())}}`;
-        case 'builder': return `builder{${printRawCellContents(r.readBuilder().endCell())}}`;
-        case 'slice':
-        case 'bitsN':
-        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 'addressExt': return r.readSlice().loadExternalAddress().toString();
-        case 'addressAny': {
-            let addr = (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, ty, r.readSlice());
-            return addr === 'none' ? 'addr_none' : addr.toString();
-        }
-        case 'nullLiteral': return r.readNullLiteral() ?? 'null';
-        case 'void': return '(void)';
-        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.readNullable((r) => debugFormat(ctx, r, fieldPath, ty.inner)) ?? '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);
-            });
-            return `ref{${innerStr.ref}}`;
-        }
-        case 'arrayOf': {
-            let items = r.readArrayOf((r) => debugFormat(ctx, r, fieldPath, ty.inner, true));
-            return `[${items.join(', ')}]`;
-        }
-        case 'lispListOf': {
-            let items = r.readLispListOf((r) => debugFormat(ctx, r, fieldPath, ty.inner, 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]));
-            }
-            return `(${parts.join(', ')})`;
-        }
-        case 'shapedTuple': {
-            return r.readTuple(ty.items.length, (r) => {
-                let parts = [];
-                for (let i = 0; i < ty.items.length; ++i) {
-                    parts.push(debugFormat(ctx, r, `${fieldPath}[${i}]`, ty.items[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 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);
-                entries.push(`${kStr}: ${vStr}`);
-            }
-            if (entries.length === 0) {
-                return 'map{}';
-            }
-            return `map{${entries.join(', ')}}`;
-        }
-        case 'EnumRef': {
-            let value = r.readBigInt();
-            let enumRef = ctx.symbols.getEnum(ty.enum_name);
-            let member = enumRef.members.find(m => BigInt(m.value) === value);
-            if (member) {
-                return `${ty.enum_name}.${member.name}`;
-            }
-            return `${ty.enum_name}(${value})`;
-        }
-        case 'StructRef': {
-            const structRef = ctx.symbols.getStruct(ty.struct_name);
-            if (structRef.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)}`);
-            }
-            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);
-        }
-        case 'union': {
-            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)
-                ];
-            }
-            // readUnionType returns `valueT` (if no label) or `{ $: "label", value: valueT }`
-            // In our case, valueT is already a string.
-            const result = r.readUnionType(ty.stack_width, infoForTypeId);
-            if (typeof result === 'string') {
-                // label is null, then it's a struct with its own $, like "Point { ... }", or it's "null"
-                return result;
-            }
-            // render "#label value": notation "#label" means "active variant of a union"
-            return `#${result.$} ${result.value}`;
-        }
-        case 'callable': {
-            r.readUnknown();
-            return 'continuation';
-        }
-        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t}`);
-    }
-}
-// 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) {
-    // 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);
-}
-// `unknown` is a raw TVM tuple item; `tuple`, by definition, is `array<unknown>`,
-// it has no compile-time type information, so visualize it anyhow
-function debugPrintUnknown(item) {
-    switch (item.type) {
-        case 'int': return `${item.value}`;
-        case 'cell': return `cell{${printRawCellContents(item.cell)}}`;
-        case 'slice': return `slice{${printRawCellContents(item.cell)}}`;
-        case 'builder': return `builder{${printRawCellContents(item.cell)}}`;
-        case 'null': return 'null';
-        case 'tuple': return `(${item.items.map(debugPrintUnknown).join(', ')})`;
-        case 'nan': return 'NaN';
-        default: return `<unknown>`;
-    }
-}
-/**
- * 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 }".
- */
-function debugPrintFromStack(ctx, r, ty) {
-    return debugFormat(ctx, r, 'self', ty);
-}

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

@@ -1,43 +0,0 @@
-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;
-    constructor(tuple: c.TupleItem[]);
-    static fromGetMethod(expectedN: number, getMethodResult: {
-        stack: c.TupleReader;
-    }): StackReader;
-    private popExpecting;
-    readBigInt(): bigint;
-    readBoolean(): boolean;
-    readCell(): c.Cell;
-    readSlice(): c.Slice;
-    readBuilder(): c.Builder;
-    readUnknown(): c.TupleItem;
-    readArrayOf<T>(readFn_T: (nestedReader: StackReader) => T): T[];
-    readLispListOf<T>(readFn_T: (nestedReader: StackReader) => T): T[];
-    readSnakeString(): string;
-    readTuple<T>(expectedN: number, readFn_T: (nestedReader: StackReader) => T): T;
-    readNullLiteral(): null;
-    readNullable<T>(readFn_T: (r: StackReader) => T): T | null;
-    readWideNullable<T>(stackW: number, readFn_T: (r: StackReader) => T): T | null;
-    readUnionType<T>(stackW: number, infoForTypeId: Record<number, [number, string | null, (r: StackReader) => any]>): T;
-    readCellRef<T>(loadFn_T: LoadCallback<T>): {
-        ref: T;
-    };
-    readDictionary<K extends c.DictionaryKeyTypes, V>(keySerializer: c.DictionaryKey<K>, valueSerializer: c.DictionaryValue<V>): c.Dictionary<K, V>;
-}
-/**
- * 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[];
-/**
- * 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`.
- * Call: `callGetMethodDynamic(provider, ctx, 'intAndPoint', [num, {x: num, y: num}])` returns `{x: num, y: num}`.
- * When input is incorrect (e.g. missing property in a JS object), throws InvalidDynamicInput.
- */
-export declare function callGetMethodDynamic(provider: c.ContractProvider, ctx: DynamicCtx, getMethodName: string, args: any[]): Promise<any>;
-export {};

package/dist/dynamic-get-methods.js

@@ -1,451 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StackReader = void 0;
-exports.makeTvmTupleDynamic = makeTvmTupleDynamic;
-exports.callGetMethodDynamic = callGetMethodDynamic;
-const c = __importStar(require("@ton/core"));
-const unsupported_errors_1 = require("./unsupported-errors");
-const dynamic_serialization_1 = require("./dynamic-serialization");
-const types_kernel_1 = require("./types-kernel");
-const dynamic_validation_1 = require("./dynamic-validation");
-class StackReader {
-    constructor(tuple) {
-        this.tuple = tuple;
-    }
-    static fromGetMethod(expectedN, getMethodResult) {
-        let tuple = [];
-        while (getMethodResult.stack.remaining) {
-            tuple.push(getMethodResult.stack.pop());
-        }
-        if (tuple.length !== expectedN) {
-            throw new Error(`expected ${expectedN} stack width, got ${tuple.length}`);
-        }
-        return new StackReader(tuple);
-    }
-    popExpecting(itemType) {
-        const item = this.tuple.shift();
-        if (item?.type !== itemType) {
-            throw new Error(`not '${itemType}' on a stack`);
-        }
-        return item;
-    }
-    readBigInt() {
-        return this.popExpecting('int').value;
-    }
-    readBoolean() {
-        return this.popExpecting('int').value !== 0n;
-    }
-    readCell() {
-        return this.popExpecting('cell').cell;
-    }
-    readSlice() {
-        return this.popExpecting('slice').cell.beginParse();
-    }
-    readBuilder() {
-        return c.beginCell().storeSlice(this.popExpecting('builder').cell.beginParse());
-    }
-    readUnknown() {
-        // `unknown` from Tolk is left as a raw tuple item
-        return this.tuple.shift();
-    }
-    readArrayOf(readFn_T) {
-        const subItems = this.popExpecting('tuple').items;
-        const subReader = new StackReader(subItems);
-        // array len N => N subItems => N calls to readFn_T
-        return [...subItems].map(_ => readFn_T(subReader));
-    }
-    readLispListOf(readFn_T) {
-        // read `[1 [2 [3 null]]]` to `[1 2 3]`
-        let pairReader = this;
-        let outArr = [];
-        while (true) {
-            if (pairReader.tuple[0].type === 'null') {
-                pairReader.tuple.shift();
-                break;
-            }
-            let headAndTail = pairReader.popExpecting('tuple').items;
-            if (headAndTail.length !== 2) {
-                throw new Error(`malformed lisp_list, expected 2 stack width, got ${headAndTail.length}`);
-            }
-            pairReader = new StackReader(headAndTail);
-            outArr.push(readFn_T(pairReader));
-        }
-        return outArr;
-    }
-    readSnakeString() {
-        return this.readCell().beginParse().loadStringTail();
-    }
-    readTuple(expectedN, readFn_T) {
-        const subItems = this.popExpecting('tuple').items;
-        if (subItems.length !== expectedN) {
-            throw new Error(`expected ${expectedN} items in a tuple, got ${subItems.length}`);
-        }
-        return readFn_T(new StackReader(subItems));
-    }
-    readNullLiteral() {
-        this.popExpecting('null');
-        return null;
-    }
-    readNullable(readFn_T) {
-        if (this.tuple[0].type === 'null') {
-            this.tuple.shift();
-            return null;
-        }
-        return readFn_T(this);
-    }
-    readWideNullable(stackW, readFn_T) {
-        const slotTypeId = this.tuple[stackW - 1];
-        if (slotTypeId?.type !== 'int') {
-            throw new Error(`not 'int' on a stack`);
-        }
-        if (slotTypeId.value === 0n) {
-            this.tuple = this.tuple.slice(stackW);
-            return null;
-        }
-        const valueT = readFn_T(this);
-        this.tuple.shift();
-        return valueT;
-    }
-    readUnionType(stackW, infoForTypeId) {
-        const slotTypeId = this.tuple[stackW - 1];
-        if (slotTypeId?.type !== 'int') {
-            throw new Error(`not 'int' on a stack`);
-        }
-        const info = infoForTypeId[Number(slotTypeId.value)]; // [stackWidth, label, readFn_T{i}]
-        if (info == null) {
-            throw new Error(`unexpected UTag=${slotTypeId.value}`);
-        }
-        const label = info[1];
-        this.tuple = this.tuple.slice(stackW - 1 - info[0]);
-        const valueT = info[2](this);
-        this.tuple.shift();
-        return label == null ? valueT : { $: label, value: valueT };
-    }
-    readCellRef(loadFn_T) {
-        return { ref: loadFn_T(this.readCell().beginParse()) };
-    }
-    readDictionary(keySerializer, valueSerializer) {
-        if (this.tuple[0].type === 'null') {
-            this.tuple.shift();
-            return c.Dictionary.empty(keySerializer, valueSerializer);
-        }
-        return c.Dictionary.loadDirect(keySerializer, valueSerializer, this.readCell());
-    }
-}
-exports.StackReader = StackReader;
-// When constructing a TVM tuple (when calling a get method), we often need to make cells.
-// For example, given an address, we should result in { type: 'slice', cell: (serialized address) }
-function makeCell(ctx, fieldPath, ty, v) {
-    let b = c.beginCell();
-    (0, dynamic_serialization_1.dynamicPack)(ctx, fieldPath, ty, v, b); // does validation, throws if invalid, e.g. number instead of address
-    return b.endCell();
-}
-// Pack value `v` of type `ty` to a TVM tuple, as an argument of a get method.
-// Parameter `fieldPath` is used for error messages only, e.g. when provided invalid input.
-function dynamicConstruct(ctx, fieldPath, ty, v, 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 dynamicConstruct(ctx, fieldPath, ty, v, false);
-        }
-        return [{ type: 'tuple', items: dynamicConstruct(ctx, fieldPath, ty, v, false) }];
-    }
-    switch (ty.kind) {
-        case 'int':
-        case 'intN':
-        case 'uintN':
-        case 'varintN':
-        case 'varuintN':
-        case 'coins': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
-            return [{ type: 'int', value: v }];
-        }
-        case 'bool': {
-            (0, dynamic_validation_1.checkIsBoolean)(fieldPath, ty, v);
-            return [{ type: 'int', value: (v ? -1n : 0n) }];
-        }
-        case 'cell': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
-            return [{ type: 'cell', cell: v }];
-        }
-        case 'builder': {
-            // the call to `makeCell()`, automatically does validation of input (of v)
-            return [{ type: 'builder', cell: makeCell(ctx, fieldPath, ty, v) }];
-        }
-        case 'slice':
-        case 'remaining':
-        case 'address':
-        case 'addressExt':
-        case 'addressAny':
-        case 'bitsN': {
-            return [{ type: 'slice', cell: makeCell(ctx, fieldPath, ty, v) }];
-        }
-        case 'string': {
-            return [{ type: 'cell', cell: makeCell(ctx, fieldPath, ty, v) }];
-        }
-        case 'addressOpt': {
-            if (v === null) {
-                return [{ type: 'null' }];
-            }
-            return [{ type: 'slice', cell: makeCell(ctx, fieldPath, ty, v) }];
-        }
-        case 'nullLiteral': {
-            return [{ type: 'null' }];
-        }
-        case 'callable': {
-            throw new unsupported_errors_1.NotSupportedTypeOnStack(ty, fieldPath);
-        }
-        case 'void': {
-            return [];
-        }
-        case 'unknown': {
-            (0, dynamic_validation_1.checkIsObjectWithProperty)(fieldPath, ty, v, 'type'); // c.TupleItem has 'type'
-            return [v];
-        }
-        case 'nullable': {
-            if (ty.stack_type_id) {
-                let result = [];
-                if (v === null) {
-                    for (let i = 0; i < ty.stack_width - 1; ++i) {
-                        result.push({ type: 'null' });
-                    }
-                    result.push({ type: 'int', value: 0n });
-                }
-                else {
-                    result = dynamicConstruct(ctx, fieldPath, ty.inner, v);
-                    result.push({ type: 'int', value: BigInt(ty.stack_type_id) });
-                }
-                return result;
-            }
-            if (v === null) {
-                return [{ type: 'null' }];
-            }
-            return dynamicConstruct(ctx, fieldPath, ty.inner, v);
-        }
-        case 'cellOf': {
-            (0, dynamic_validation_1.checkIsObjectWithProperty)(fieldPath, ty, v, 'ref');
-            return [{ type: 'cell', cell: makeCell(ctx, fieldPath, ty.inner, v.ref) }];
-        }
-        case 'arrayOf': {
-            (0, dynamic_validation_1.checkIsArray)(fieldPath, ty, v);
-            return [{ type: 'tuple', items: v.map((ith) => dynamicConstruct(ctx, 'ith', ty.inner, ith, true)[0]) }];
-        }
-        case 'lispListOf': {
-            (0, dynamic_validation_1.checkIsArray)(fieldPath, ty, v);
-            return [v.reduceRight((tail, head) => ({ type: 'tuple', items: [dynamicConstruct(ctx, 'head', ty.inner, head, true)[0], tail] }), { type: 'null' })];
-        }
-        case 'tensor': {
-            (0, dynamic_validation_1.checkIsArray)(fieldPath, ty, v, ty.items.length);
-            return v.flatMap((item, idx) => dynamicConstruct(ctx, `${fieldPath}[${idx}]`, ty.items[idx], item));
-        }
-        case 'shapedTuple': {
-            (0, dynamic_validation_1.checkIsArray)(fieldPath, ty, v, ty.items.length);
-            return [{ type: 'tuple', items: v.map((ith, idx) => dynamicConstruct(ctx, `${fieldPath}[${idx}]`, ty.items[idx], ith, true)[0]) }];
-        }
-        case 'mapKV': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
-            if (v.size === 0) {
-                return [{ type: 'null' }];
-            }
-            let dictKey = (0, dynamic_serialization_1.createTonCoreDictionaryKey)(fieldPath, ty.k);
-            let dictValue = (0, dynamic_serialization_1.createTonCoreDictionaryValue)(ctx, fieldPath, ty.v);
-            return [{ type: 'cell', cell: c.beginCell().storeDictDirect(v, dictKey, dictValue).endCell() }];
-        }
-        case 'EnumRef': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
-            return [{ type: 'int', value: v }];
-        }
-        case 'StructRef': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
-            let 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 dynamicConstruct(ctx, `${fieldPath}.${f.name}`, fTy, v[f.name]);
-            });
-        }
-        case 'AliasRef': {
-            let 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 dynamicConstruct(ctx, fieldPath, targetTy, v);
-        }
-        case 'union': {
-            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
-            const hasNull = variants.find(v => v.variant_ty.kind === 'nullLiteral');
-            let result = [];
-            if (hasNull && v === null) {
-                for (let i = 0; i < ty.stack_width - 1; ++i) {
-                    result.push({ type: 'null' });
-                }
-                result.push({ type: 'int', value: 0n });
-            }
-            else {
-                (0, dynamic_validation_1.checkIsObjectWithProperty)(fieldPath, ty, v, '$');
-                const activeVariant = variants.find(variant => v.$ === variant.labelStr);
-                if (!activeVariant) {
-                    (0, dynamic_validation_1.throwInvalidInput)(fieldPath, ty, `non-existing union variant for $ = '${v.$}'`);
-                }
-                if (activeVariant.hasValueField && !v.hasOwnProperty('value')) {
-                    (0, dynamic_validation_1.throwInvalidInput)(fieldPath, ty, `expected {$,value} but field 'value' not provided`);
-                }
-                for (let i = 0; i < ty.stack_width - 1 - activeVariant.stack_width; ++i) {
-                    result.push({ type: 'null' });
-                }
-                let actualValue = activeVariant.hasValueField ? v.value : v;
-                result.push(...dynamicConstruct(ctx, `${fieldPath}#${activeVariant.labelStr}`, activeVariant.variant_ty, actualValue));
-                result.push({ type: 'int', value: BigInt(activeVariant.stack_type_id) });
-            }
-            return result;
-        }
-        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} at ${fieldPath}`);
-    }
-}
-// Parse `ty` from a TVM tuple on a stack, returned as a result of a get method invocation.
-// Parameter `fieldPath` is used for error messages only, e.g. when can't deserialize CellRef<T>.
-function dynamicParse(ctx, r, fieldPath, ty, unTupleIfW = false) {
-    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(wOnStack, (r) => dynamicParse(ctx, r, 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 dynamicParse(ctx, r, fieldPath, { kind: 'nullable', inner: { kind: 'address' } });
-        case 'addressExt': return r.readSlice().loadExternalAddress();
-        case 'addressAny': return (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, ty, 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(ty.stack_width, (r) => dynamicParse(ctx, r, fieldPath, ty.inner));
-            }
-            return r.readNullable((r) => dynamicParse(ctx, r, fieldPath, ty.inner));
-        }
-        case 'cellOf': return r.readCellRef((s) => (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, ty.inner, s));
-        case 'arrayOf': return r.readArrayOf((r) => dynamicParse(ctx, r, fieldPath, ty.inner, true));
-        case 'lispListOf': return r.readLispListOf((r) => dynamicParse(ctx, r, fieldPath, ty.inner, true));
-        case 'tensor': {
-            let result = [];
-            for (let i = 0; i < ty.items.length; ++i) {
-                result.push(dynamicParse(ctx, r, `${fieldPath}[${i}]`, ty.items[i]));
-            }
-            return result;
-        }
-        case 'shapedTuple': {
-            return r.readTuple(ty.items.length, (r) => {
-                let result = [];
-                for (let i = 0; i < ty.items.length; ++i) {
-                    result.push(dynamicParse(ctx, r, `${fieldPath}[${i}]`, ty.items[i], true));
-                }
-                return result;
-            });
-        }
-        case 'mapKV': {
-            let dictKey = (0, dynamic_serialization_1.createTonCoreDictionaryKey)(fieldPath, ty.k);
-            let dictValue = (0, dynamic_serialization_1.createTonCoreDictionaryValue)(ctx, fieldPath, ty.v);
-            return r.readDictionary(dictKey, dictValue);
-        }
-        case 'EnumRef': return r.readBigInt();
-        case 'StructRef': {
-            const structRef = ctx.symbols.getStruct(ty.struct_name);
-            let result = { $: 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;
-                result[f.name] = dynamicParse(ctx, r, `${fieldPath}.${f.name}`, fTy);
-            }
-            return result;
-        }
-        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 dynamicParse(ctx, r, fieldPath, targetTy);
-        }
-        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} at ${fieldPath}`);
-        case 'union': {
-            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
-            const infoForTypeId = {};
-            for (let v of variants) {
-                infoForTypeId[v.stack_type_id] = [v.stack_width, v.hasValueField ? v.labelStr : null,
-                    (r) => dynamicParse(ctx, r, `${fieldPath}#${v.labelStr}`, v.variant_ty)
-                ];
-            }
-            return r.readUnionType(ty.stack_width, infoForTypeId);
-        }
-    }
-}
-/**
- * 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.
- */
-function makeTvmTupleDynamic(ctx, ty, value) {
-    return dynamicConstruct(ctx, 'value', ty, value);
-}
-/**
- * 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`.
- * Call: `callGetMethodDynamic(provider, ctx, 'intAndPoint', [num, {x: num, y: num}])` returns `{x: num, y: num}`.
- * When input is incorrect (e.g. missing property in a JS object), throws InvalidDynamicInput.
- */
-async function callGetMethodDynamic(provider, ctx, getMethodName, args) {
-    const getM = ctx.findGetMethod(getMethodName);
-    if (getM == null) {
-        throw new unsupported_errors_1.CantCallGetMethodDynamic(getMethodName, `method not found in contract ${ctx.contractName}`);
-    }
-    if (getM.parameters.length !== args.length) { // default parameters not supported, dynamic invocation should provide all
-        throw new unsupported_errors_1.CantCallGetMethodDynamic(getMethodName, `expected ${getM.parameters.length} arguments, got ${args.length}`);
-    }
-    const stackIn = [];
-    for (let i = 0; i < args.length; ++i) {
-        stackIn.push(...dynamicConstruct(ctx, getM.parameters[i].name, getM.parameters[i].ty, args[i]));
-    }
-    const expectedSlotsOut = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, getM.return_ty);
-    const r = StackReader.fromGetMethod(expectedSlotsOut, await provider.get(getMethodName, stackIn));
-    return dynamicParse(ctx, r, 'result', getM.return_ty);
-}