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

package/dist/dynamic-ctx.d.ts

@@ -0,0 +1,17 @@
+import * as c from '@ton/core';
+import { SymTable } from './codegen-ctx';
+import { ABIGetMethod, ContractABI } from './abi';
+type CustomPackToBuilderFn<T> = (self: T, b: c.Builder) => void;
+type CustomUnpackFromSliceFn<T> = (s: c.Slice) => T;
+export declare class DynamicCtx {
+    readonly contractName: string;
+    readonly getMethods: ABIGetMethod[];
+    readonly symbols: SymTable;
+    private customSerializersRegistry;
+    constructor(contract: 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>;
+    findGetMethod(getMethodName: string): ABIGetMethod | undefined;
+}
+export {};

package/dist/dynamic-ctx.js

@@ -0,0 +1,39 @@
+"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");
+class DynamicCtx {
+    constructor(contract) {
+        this.customSerializersRegistry = new Map;
+        this.contractName = contract.contract_name;
+        this.getMethods = contract.get_methods;
+        this.symbols = new codegen_ctx_1.SymTable(contract.declarations);
+    }
+    registerCustomPackUnpack(typeName, packToBuilderFn, unpackFromSliceFn) {
+        if (this.customSerializersRegistry.has(typeName)) {
+            throw new Error(`Custom pack/unpack for '${typeName}' already registered`);
+        }
+        this.customSerializersRegistry.set(typeName, [packToBuilderFn, unpackFromSliceFn]);
+    }
+    getCustomPackFnOrThrow(typeName, fieldPath) {
+        let packUnpack = this.customSerializersRegistry.get(typeName);
+        let packFn = packUnpack ? packUnpack[0] : null;
+        if (!packFn) {
+            throw new unsupported_errors_1.CantPackDynamic(fieldPath, `custom packToBuilder was not registered for '${typeName}'`);
+        }
+        return packFn;
+    }
+    getCustomUnpackFnOrThrow(typeName, fieldPath) {
+        let packUnpack = this.customSerializersRegistry.get(typeName);
+        let unpackFn = packUnpack ? packUnpack[1] : null;
+        if (!unpackFn) {
+            throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, `custom unpackFromSlice was not registered for '${typeName}'`);
+        }
+        return unpackFn;
+    }
+    findGetMethod(getMethodName) {
+        return this.getMethods.find(m => m.name === getMethodName);
+    }
+}
+exports.DynamicCtx = DynamicCtx;

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

@@ -0,0 +1,9 @@
+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;

package/dist/dynamic-debug-print.js

@@ -0,0 +1,183 @@
+"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

@@ -0,0 +1,43 @@
+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 {};