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

package/dist/dynamic-get-methods.js

@@ -0,0 +1,451 @@
+"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);
+}

package/dist/dynamic-serialization.d.ts

@@ -0,0 +1,22 @@
+import * as c from '@ton/core';
+import type { Ty } from './abi-types';
+import { DynamicCtx } from './dynamic-ctx';
+export declare function createTonCoreDictionaryKey(fieldPath: string, tyK: Ty): c.DictionaryKey<any>;
+export declare function createTonCoreDictionaryValue(ctx: DynamicCtx, fieldPath: string, tyV: Ty): c.DictionaryValue<any>;
+export declare function dynamicPack(ctx: DynamicCtx, fieldPath: string, ty: Ty, v: any, b: c.Builder): void;
+export declare function dynamicUnpack(ctx: DynamicCtx, fieldPath: string, ty: Ty, s: c.Slice): any;
+/**
+ * Pack any input to a builder according to an ABI schema.
+ * Example: `struct Point { x: int8, y: int8 }`.
+ * After being converted, it's stored as ABI.
+ * Call: `packToBuilderDynamic(ctx, structTy, { x: 10, y: 20 }, b)` appends 0x0A14.
+ * When input is incorrect (e.g. missing property in a JS object), throws InvalidDynamicInput.
+ */
+export declare function packToBuilderDynamic(ctx: DynamicCtx, ty: Ty, value: any, b: c.Builder): void;
+/**
+ * Unpack any slice to a JS variable according to an ABI schema.
+ * Example: `struct Point { x: int8, y: int8 }`.
+ * Call: `unpackFromSliceDynamic(ctx, structTy, hex"0A14")` returns `{ x: 10, y: 20 }`.
+ * When ty can't be deserialized, throws CantUnpackDynamic.
+ */
+export declare function unpackFromSliceDynamic(ctx: DynamicCtx, ty: Ty, s: c.Slice): any;