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

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/{src/dynamic-debug-print.ts → dist/dynamic-debug-print.js}

@@ -1,10 +1,9 @@
-import * as c from '@ton/core';
-import { DynamicCtx } from './dynamic-ctx';
-import { Ty } from './abi-types';
-import { makeTvmTupleDynamic, StackReader } from './dynamic-get-methods';
-import { createTonCoreDictionaryKey, createTonCoreDictionaryValue, dynamicUnpack } from './dynamic-serialization';
-import { calcWidthOnStack, createLabelsForUnion, instantiateGenerics, renderTy } from './types-kernel';
-
+"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),
@@ -12,54 +11,51 @@ import { calcWidthOnStack, createLabelsForUnion, instantiateGenerics, renderTy }
     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: c.Cell): string {
+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: DynamicCtx, r: StackReader, fieldPath: string, ty: Ty, unTupleIfW = false): string {
+function debugFormat(ctx, r, fieldPath, ty, unTupleIfW = false) {
     if (unTupleIfW) {
-        let wOnStack = calcWidthOnStack(ctx.symbols, ty);
+        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 '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 '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 = dynamicUnpack(ctx, fieldPath, ty, r.readSlice());
+            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 'void': return '(void)';
+        case 'unknown': return debugPrintUnknown(r.readUnknown());
         case 'nullable': {
-            if (ty.stackTypeId) {
-                return r.readWideNullable(ty.stackWidth!, (r) => debugFormat(ctx, r, fieldPath, ty.inner)) ?? 'null';
+            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 = dynamicUnpack(ctx, fieldPath, ty.inner, s);
+                const deserialized = (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, ty.inner, s);
                 return debugFormatValue(ctx, fieldPath, ty.inner, deserialized);
             });
             return `ref{${innerStr.ref}}`;
@@ -73,7 +69,7 @@ function debugFormat(ctx: DynamicCtx, r: StackReader, fieldPath: string, ty: Ty,
             return `[${items.join(', ')}]`;
         }
         case 'tensor': {
-            let parts: string[] = [];
+            let parts = [];
             for (let i = 0; i < ty.items.length; ++i) {
                 parts.push(debugFormat(ctx, r, `${fieldPath}[${i}]`, ty.items[i]));
             }
@@ -81,7 +77,7 @@ function debugFormat(ctx: DynamicCtx, r: StackReader, fieldPath: string, ty: Ty,
         }
         case 'shapedTuple': {
             return r.readTuple(ty.items.length, (r) => {
-                let parts: string[] = [];
+                let parts = [];
                 for (let i = 0; i < ty.items.length; ++i) {
                     parts.push(debugFormat(ctx, r, `${fieldPath}[${i}]`, ty.items[i], true));
                 }
@@ -89,9 +85,9 @@ function debugFormat(ctx: DynamicCtx, r: StackReader, fieldPath: string, ty: Ty,
             });
         }
         case 'mapKV': {
-            let dictKey = createTonCoreDictionaryKey(fieldPath, ty.k);
-            let dictValue = createTonCoreDictionaryValue(ctx, fieldPath, ty.v);
-            let entries: string[] = [];
+            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);
@@ -104,41 +100,41 @@ function debugFormat(ctx: DynamicCtx, r: StackReader, fieldPath: string, ty: Ty,
         }
         case 'EnumRef': {
             let value = r.readBigInt();
-            let enumRef = ctx.symbols.getEnum(ty.enumName);
+            let enumRef = ctx.symbols.getEnum(ty.enum_name);
             let member = enumRef.members.find(m => BigInt(m.value) === value);
             if (member) {
-                return `${ty.enumName}.${member.name}`;
+                return `${ty.enum_name}.${member.name}`;
             }
-            return `${ty.enumName}(${value})`;
+            return `${ty.enum_name}(${value})`;
         }
         case 'StructRef': {
-            const structRef = ctx.symbols.getStruct(ty.structName);
+            const structRef = ctx.symbols.getStruct(ty.struct_name);
             if (structRef.fields.length === 0) {
-                return `${ty.structName} {}`;
+                return `${ty.struct_name} {}`;
             }
-            const fieldStrs: string[] = [];
+            const fieldStrs = [];
             for (const f of structRef.fields) {
-                const fTy = ty.typeArgs ? instantiateGenerics(f.ty, structRef.typeParams, ty.typeArgs) : f.ty;
+                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.structName} { ${fieldStrs.join(', ')} }`;
+            return `${ty.struct_name} { ${fieldStrs.join(', ')} }`;
         }
         case 'AliasRef': {
-            const aliasRef = ctx.symbols.getAlias(ty.aliasName);
-            const targetTy = ty.typeArgs ? instantiateGenerics(aliasRef.targetTy, aliasRef.typeParams, ty.typeArgs) : aliasRef.targetTy;
+            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 = createLabelsForUnion(ctx.symbols, ty.variants);
-            const infoForTypeId = {} as Record<number, [number, string | null, (r: StackReader) => string]>;
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
+            const infoForTypeId = {};
             for (let v of variants) {
-                infoForTypeId[v.stackTypeId] = [v.stackWidth, v.hasValueField ? v.labelStr : null,
-                    (r: StackReader) => debugFormat(ctx, r, `${fieldPath}#${v.labelStr}`, v.variantTy)
+                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<string | { $: string, value: string }>(ty.stackWidth, infoForTypeId);
+            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;
@@ -150,42 +146,38 @@ function debugFormat(ctx: DynamicCtx, r: StackReader, fieldPath: string, ty: Ty,
             r.readUnknown();
             return 'continuation';
         }
-        case 'genericT': throw new Error(`unexpected genericT=${ty.nameT}`);
+        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: DynamicCtx, fieldPath: string, ty: Ty, value: any): 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 = makeTvmTupleDynamic(ctx, ty, value);
-    return debugFormat(ctx, new StackReader(backToTuple), fieldPath, ty);
+    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: c.TupleItem): string {
+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 '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>`;
+        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 }".
  */
-export function debugPrintFromStack(ctx: DynamicCtx, r: StackReader, ty: Ty): string {
+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 {};