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

package/dist/dynamic-serialization.js

@@ -0,0 +1,453 @@
+"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.createTonCoreDictionaryKey = createTonCoreDictionaryKey;
+exports.createTonCoreDictionaryValue = createTonCoreDictionaryValue;
+exports.dynamicPack = dynamicPack;
+exports.dynamicUnpack = dynamicUnpack;
+exports.packToBuilderDynamic = packToBuilderDynamic;
+exports.unpackFromSliceDynamic = unpackFromSliceDynamic;
+const c = __importStar(require("@ton/core"));
+const unsupported_errors_1 = require("./unsupported-errors");
+const dynamic_validation_1 = require("./dynamic-validation");
+const types_kernel_1 = require("./types-kernel");
+/*
+    Dynamic serialization works without generating TypeScript wrappers.
+    Just given an ABI, serialize any JS input to a cell, and unpack back.
+    Its purpose is orthogonal to wrappers:
+    - wrappers — for manual development
+                 (write tests, deployment, and other manual interactions with your contract)
+    - dynamic serialization — for tolk-js, explorers, etc.
+                 (pass some data from auto-generated UI to some contract just given its ABI)
+ */
+function lookupPrefix(s, expected, prefixLen) {
+    return s.remainingBits >= prefixLen && s.preloadUint(prefixLen) === expected;
+}
+function createTonCoreDictionaryKey(fieldPath, tyK) {
+    if (tyK.kind === 'intN')
+        return c.Dictionary.Keys.BigInt(tyK.n);
+    if (tyK.kind === 'uintN')
+        return c.Dictionary.Keys.BigUint(tyK.n);
+    if (tyK.kind === 'address')
+        return c.Dictionary.Keys.Address();
+    throw new unsupported_errors_1.NonStandardDictKey(`'${fieldPath}' is 'map<${(0, types_kernel_1.renderTy)(tyK)}, ...>': such a non-standard map key can not be handled by @ton/core library`);
+}
+function createTonCoreDictionaryValue(ctx, fieldPath, tyV) {
+    return {
+        serialize(self, b) {
+            dynamicPack(ctx, fieldPath, tyV, self, b);
+        },
+        parse(s) {
+            return dynamicUnpack(ctx, fieldPath, tyV, s);
+        }
+    };
+}
+// Parameter `fieldPath` is used for error messages only, e.g. when provided invalid input.
+function dynamicPack(ctx, fieldPath, ty, v, b) {
+    switch (ty.kind) {
+        case 'intN': {
+            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            b.storeInt(v, ty.n);
+            break;
+        }
+        case 'uintN': {
+            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            b.storeUint(v, ty.n);
+            break;
+        }
+        case 'varintN': {
+            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            b.storeVarInt(v, Math.log2(ty.n));
+            break;
+        }
+        case 'varuintN': {
+            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            b.storeVarUint(v, Math.log2(ty.n));
+            break;
+        }
+        case 'coins': {
+            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            b.storeCoins(v);
+            break;
+        }
+        case 'bool': {
+            (0, dynamic_validation_1.checkIsBoolean)(fieldPath, ty, v);
+            b.storeBit(v);
+            break;
+        }
+        case 'cell': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            b.storeRef(v);
+            break;
+        }
+        case 'builder': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            b.storeBuilder(v);
+            break;
+        }
+        case 'slice': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            b.storeSlice(v);
+            break;
+        }
+        case 'string': {
+            (0, dynamic_validation_1.checkIsString)(fieldPath, ty, v);
+            b.storeStringRefTail(v);
+            break;
+        }
+        case 'remaining': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            b.storeSlice(v);
+            break;
+        }
+        case 'address': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            b.storeAddress(v);
+            break;
+        }
+        case 'addressOpt': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v, true);
+            b.storeAddress(v);
+            break;
+        }
+        case 'addressExt': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            b.storeAddress(v);
+            break;
+        }
+        case 'addressAny': {
+            if (v === 'none') {
+                b.storeAddress(null);
+            }
+            else {
+                (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+                b.storeAddress(v);
+            }
+            break;
+        }
+        case 'bitsN': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            if (v.remainingBits !== ty.n || v.remainingRefs !== 0) {
+                (0, dynamic_validation_1.throwInvalidInput)(fieldPath, ty, `expected ${ty.n} bits and 0 refs, got ${v.remainingBits} bits and ${v.remainingRefs} refs`);
+            }
+            b.storeSlice(v);
+            break;
+        }
+        case 'nullable': {
+            if (v === null) {
+                b.storeUint(0, 1);
+            }
+            else {
+                b.storeUint(1, 1);
+                dynamicPack(ctx, fieldPath, ty.inner, v, b);
+            }
+            break;
+        }
+        case 'cellOf': {
+            (0, dynamic_validation_1.checkIsObjectWithProperty)(fieldPath, ty, v, 'ref');
+            let b_ref = c.beginCell();
+            dynamicPack(ctx, fieldPath, ty.inner, v.ref, b_ref);
+            b.storeRef(b_ref.endCell());
+            break;
+        }
+        case 'arrayOf': {
+            (0, dynamic_validation_1.checkIsArray)(fieldPath, ty, v);
+            // the compiler stores array<T> in chunks; in TypeScript, for simplicity, store "1 elem = 1 ref"
+            let tail = null;
+            for (let i = 0; i < v.length; ++i) {
+                let chunkB = c.beginCell().storeMaybeRef(tail);
+                dynamicPack(ctx, fieldPath + '[ith]', ty.inner, v[v.length - 1 - i], chunkB);
+                tail = chunkB.endCell();
+            }
+            b.storeUint(v.length, 8);
+            b.storeMaybeRef(tail);
+            break;
+        }
+        case 'lispListOf': {
+            (0, dynamic_validation_1.checkIsArray)(fieldPath, ty, v);
+            let tail = c.Cell.EMPTY;
+            for (let i = 0; i < v.length; ++i) {
+                let itemB = c.beginCell();
+                dynamicPack(ctx, `${fieldPath}[${i}]`, ty.inner, v[i], itemB);
+                tail = itemB.storeRef(tail).endCell();
+            }
+            b.storeRef(tail);
+            break;
+        }
+        case 'tensor': // `(T1, T2)` and `[T1, T2]` are both TypeScript arrays
+        case 'shapedTuple': { // (but in Tolk, they are different: a tensor and a TVM shaped tuple)
+            (0, dynamic_validation_1.checkIsArray)(fieldPath, ty, v, ty.items.length);
+            for (let i = 0; i < v.length; ++i) {
+                dynamicPack(ctx, `${fieldPath}[${i}]`, ty.items[i], v[i], b);
+            }
+            break;
+        }
+        case 'mapKV': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            let dictKey = createTonCoreDictionaryKey(fieldPath, ty.k);
+            let dictValue = createTonCoreDictionaryValue(ctx, fieldPath, ty.v);
+            b.storeDict(v, dictKey, dictValue);
+            break;
+        }
+        case 'EnumRef': {
+            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            let enumRef = ctx.symbols.getEnum(ty.enum_name);
+            if (enumRef.custom_pack_unpack?.pack_to_builder) {
+                ctx.getCustomPackFnOrThrow(ty.enum_name, fieldPath)(v, b);
+                break;
+            }
+            dynamicPack(ctx, fieldPath, enumRef.encoded_as, v, b);
+            break;
+        }
+        case 'StructRef': {
+            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            let structRef = ctx.symbols.getStruct(ty.struct_name);
+            if (structRef.custom_pack_unpack?.pack_to_builder) {
+                ctx.getCustomPackFnOrThrow(ty.struct_name, fieldPath)(v, b);
+                break;
+            }
+            if (structRef.prefix) {
+                b.storeUint(+structRef.prefix.prefix_str, structRef.prefix.prefix_len);
+            }
+            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;
+                try {
+                    dynamicPack(ctx, `${fieldPath}.${f.name}`, fTy, v[f.name], b);
+                }
+                catch (ex) {
+                    if (ex instanceof unsupported_errors_1.InvalidDynamicInput) {
+                        throw ex;
+                    }
+                    // serialization errors from @ton/core, like "value is out of range"
+                    (0, dynamic_validation_1.throwInvalidInput)(`${fieldPath}.${f.name}`, fTy, ex.message ?? ex.toString());
+                }
+            }
+            break;
+        }
+        case 'AliasRef': {
+            let aliasRef = ctx.symbols.getAlias(ty.alias_name);
+            if (aliasRef.custom_pack_unpack?.pack_to_builder) {
+                ctx.getCustomPackFnOrThrow(ty.alias_name, fieldPath)(v, b);
+                break;
+            }
+            const targetTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(aliasRef.target_ty, aliasRef.type_params, ty.type_args) : aliasRef.target_ty;
+            dynamicPack(ctx, fieldPath, targetTy, v, b);
+            break;
+        }
+        case 'union': {
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
+            const hasNull = variants.find(v => v.variant_ty.kind === 'nullLiteral');
+            if (hasNull && v === null) {
+                b.storeUint(+hasNull.prefix_str, hasNull.prefix_len);
+            }
+            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`);
+                }
+                if (activeVariant.is_prefix_implicit) {
+                    b.storeUint(+activeVariant.prefix_str, activeVariant.prefix_len);
+                }
+                let actualValue = activeVariant.hasValueField ? v.value : v;
+                dynamicPack(ctx, `${fieldPath}#${activeVariant.labelStr}`, activeVariant.variant_ty, actualValue, b);
+            }
+            break;
+        }
+        case 'void':
+            break;
+        default:
+            throw new unsupported_errors_1.CantPackDynamic(fieldPath, `type '${(0, types_kernel_1.renderTy)(ty)}' is not serializable`);
+    }
+}
+// Parameter `fieldPath` is used for error messages only, e.g. when can't deserialize exact field (bad slice).
+function dynamicUnpack(ctx, fieldPath, ty, s) {
+    switch (ty.kind) {
+        case 'intN': return s.loadIntBig(ty.n);
+        case 'uintN': return s.loadUintBig(ty.n);
+        case 'varintN': return s.loadVarIntBig(Math.log2(ty.n));
+        case 'varuintN': return s.loadVarUintBig(Math.log2(ty.n));
+        case 'coins': return s.loadCoins();
+        case 'bool': return s.loadBoolean();
+        case 'cell': return s.loadRef();
+        case 'string': return s.loadStringRefTail();
+        case 'remaining': {
+            let rest = s.clone();
+            s.loadBits(s.remainingBits);
+            while (s.remainingRefs) {
+                s.loadRef();
+            }
+            return rest;
+        }
+        case 'address': return s.loadAddress();
+        case 'addressOpt': return s.loadMaybeAddress();
+        case 'addressExt': return s.loadExternalAddress();
+        case 'addressAny': {
+            let maybe_addr = s.loadAddressAny();
+            return maybe_addr === null ? 'none' : maybe_addr;
+        }
+        case 'bitsN': return new c.Slice(new c.BitReader(s.loadBits(ty.n)), []);
+        case 'nullLiteral': return null;
+        case 'nullable': return s.loadBoolean() ? dynamicUnpack(ctx, fieldPath, ty.inner, s) : null;
+        case 'cellOf': {
+            let s_ref = s.loadRef().beginParse();
+            return { ref: dynamicUnpack(ctx, fieldPath, ty.inner, s_ref) };
+        }
+        case 'arrayOf': {
+            let len = s.loadUint(8);
+            let head = s.loadMaybeRef();
+            let outArr = [];
+            while (head != null) {
+                let s = head.beginParse();
+                head = s.loadMaybeRef();
+                while (s.remainingBits || s.remainingRefs) {
+                    outArr.push(dynamicUnpack(ctx, fieldPath + '[ith]', ty.inner, s));
+                }
+            }
+            if (len !== outArr.length) {
+                throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, `mismatch array binary data: expected ${len} elements, got ${outArr.length}`);
+            }
+            return outArr;
+        }
+        case 'lispListOf': {
+            let outArr = [];
+            let head = s.loadRef().beginParse();
+            while (head.remainingRefs) {
+                let tailSnaked = head.loadRef();
+                let headValue = dynamicUnpack(ctx, fieldPath + '[ith]', ty.inner, head);
+                head.endParse(); // ensure no data is present besides T
+                outArr.unshift(headValue);
+                head = tailSnaked.beginParse();
+            }
+            return outArr;
+        }
+        case 'tensor':
+        case 'shapedTuple': {
+            return ty.items.map((item, idx) => dynamicUnpack(ctx, `${fieldPath}[${idx}]`, item, s));
+        }
+        case 'mapKV': {
+            let dictKey = createTonCoreDictionaryKey(fieldPath, ty.k);
+            let dictValue = createTonCoreDictionaryValue(ctx, fieldPath, ty.v);
+            return s.loadDict(dictKey, dictValue);
+        }
+        case 'EnumRef': {
+            let enumRef = ctx.symbols.getEnum(ty.enum_name);
+            if (enumRef.custom_pack_unpack?.unpack_from_slice) {
+                return ctx.getCustomUnpackFnOrThrow(ty.enum_name, fieldPath)(s);
+            }
+            return dynamicUnpack(ctx, fieldPath, enumRef.encoded_as, s);
+        }
+        case 'StructRef': {
+            let structRef = ctx.symbols.getStruct(ty.struct_name);
+            if (structRef.custom_pack_unpack?.unpack_from_slice) {
+                return ctx.getCustomUnpackFnOrThrow(ty.struct_name, fieldPath)(s);
+            }
+            let result = { $: ty.struct_name };
+            if (structRef.prefix) {
+                let prefix = s.loadUint(structRef.prefix.prefix_len);
+                if (prefix !== +structRef.prefix.prefix_str) {
+                    throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, `incorrect prefix for '${ty.struct_name}', expected ${structRef.prefix.prefix_str}`);
+                }
+            }
+            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;
+                try {
+                    result[f.name] = dynamicUnpack(ctx, `${fieldPath}.${f.name}`, fTy, s);
+                }
+                catch (ex) {
+                    if (ex instanceof unsupported_errors_1.CantUnpackDynamic) {
+                        throw ex;
+                    }
+                    // deserialization errors due to invalid slice, show field name
+                    throw new unsupported_errors_1.CantUnpackDynamic(`${fieldPath}.${f.name}`, ex.message ?? ex.toString());
+                }
+            }
+            return result;
+        }
+        case 'AliasRef': {
+            let aliasRef = ctx.symbols.getAlias(ty.alias_name);
+            if (aliasRef.custom_pack_unpack?.unpack_from_slice) {
+                return ctx.getCustomUnpackFnOrThrow(ty.alias_name, fieldPath)(s);
+            }
+            const targetTy = ty.type_args ? (0, types_kernel_1.instantiateGenerics)(aliasRef.target_ty, aliasRef.type_params, ty.type_args) : aliasRef.target_ty;
+            return dynamicUnpack(ctx, fieldPath, targetTy, s);
+        }
+        case 'genericT': throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, 'unexpected genericT');
+        case 'union': {
+            for (const variant of (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants)) {
+                if (!lookupPrefix(s, +variant.prefix_str, variant.prefix_len)) {
+                    continue;
+                }
+                if (variant.is_prefix_implicit) {
+                    s.skip(variant.prefix_len);
+                }
+                let actualValue = dynamicUnpack(ctx, `${fieldPath}#${variant.labelStr}`, variant.variant_ty, s);
+                if (!variant.hasValueField) {
+                    return actualValue;
+                }
+                return { $: variant.labelStr, value: actualValue };
+            }
+            throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, 'none of union prefixes match');
+        }
+        case 'void':
+            return void 0;
+        default:
+            throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, `type '${(0, types_kernel_1.renderTy)(ty)}' is not serializable`);
+    }
+}
+/**
+ * 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.
+ */
+function packToBuilderDynamic(ctx, ty, value, b) {
+    let fieldPath = ty.kind === 'StructRef' ? ty.struct_name : 'self';
+    dynamicPack(ctx, fieldPath, ty, value, b);
+}
+/**
+ * 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.
+ */
+function unpackFromSliceDynamic(ctx, ty, s) {
+    let fieldPath = ty.kind === 'StructRef' ? ty.struct_name : 'self';
+    return dynamicUnpack(ctx, fieldPath, ty, s);
+}

package/dist/dynamic-validation.d.ts

@@ -0,0 +1,8 @@
+import type { Ty } from './abi-types';
+export declare function throwInvalidInput(fieldPath: string, expectedTy: Ty, msgWhyInvalid: string): never;
+export declare function checkIsNumber(fieldPath: string, expectedTy: Ty, passedV: any): void;
+export declare function checkIsBoolean(fieldPath: string, expectedTy: Ty, passedV: any): void;
+export declare function checkIsString(fieldPath: string, expectedTy: Ty, passedV: any): void;
+export declare function checkIsArray(fieldPath: string, expectedTy: Ty, passedV: any, expectedLen?: number): void;
+export declare function checkIsObject(fieldPath: string, expectedTy: Ty, passedV: any, allowNull?: boolean): void;
+export declare function checkIsObjectWithProperty(fieldPath: string, expectedTy: Ty, passedV: any, propertyName: string): void;

package/{src/dynamic-validation.ts → dist/dynamic-validation.js}

@@ -1,33 +1,36 @@
-import type { Ty } from './abi-types'
-import { InvalidDynamicInput } from './unsupported-errors'
-import { renderTy } from './types-kernel'
-
-export function throwInvalidInput(fieldPath: string, expectedTy: Ty, msgWhyInvalid: string): never {
-    throw new InvalidDynamicInput(`invalid value passed for '${fieldPath}' of type '${renderTy(expectedTy)}': ${msgWhyInvalid}`);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwInvalidInput = throwInvalidInput;
+exports.checkIsNumber = checkIsNumber;
+exports.checkIsBoolean = checkIsBoolean;
+exports.checkIsString = checkIsString;
+exports.checkIsArray = checkIsArray;
+exports.checkIsObject = checkIsObject;
+exports.checkIsObjectWithProperty = checkIsObjectWithProperty;
+const unsupported_errors_1 = require("./unsupported-errors");
+const types_kernel_1 = require("./types-kernel");
+function throwInvalidInput(fieldPath, expectedTy, msgWhyInvalid) {
+    throw new unsupported_errors_1.InvalidDynamicInput(`invalid value passed for '${fieldPath}' of type '${(0, types_kernel_1.renderTy)(expectedTy)}': ${msgWhyInvalid}`);
 }
-
-export function checkIsNumber(fieldPath: string, expectedTy: Ty, passedV: any): void {
+function checkIsNumber(fieldPath, expectedTy, passedV) {
     let isNumber = typeof passedV === 'bigint' || typeof passedV === 'number';
     if (!isNumber) {
         throwInvalidInput(fieldPath, expectedTy, 'not a number');
     }
 }
-
-export function checkIsBoolean(fieldPath: string, expectedTy: Ty, passedV: any): void {
+function checkIsBoolean(fieldPath, expectedTy, passedV) {
     let isBoolean = typeof passedV === 'boolean';
     if (!isBoolean) {
         throwInvalidInput(fieldPath, expectedTy, 'not a boolean');
     }
 }
-
-export function checkIsString(fieldPath: string, expectedTy: Ty, passedV: any): void {
+function checkIsString(fieldPath, expectedTy, passedV) {
     let isString = typeof passedV === 'string';
     if (!isString) {
         throwInvalidInput(fieldPath, expectedTy, 'not a string');
     }
 }
-
-export function checkIsArray(fieldPath: string, expectedTy: Ty, passedV: any, expectedLen?: number): void {
+function checkIsArray(fieldPath, expectedTy, passedV, expectedLen) {
     let isArray = Array.isArray(passedV);
     if (!isArray) {
         throwInvalidInput(fieldPath, expectedTy, 'not an array');
@@ -36,8 +39,7 @@ export function checkIsArray(fieldPath: string, expectedTy: Ty, passedV: any, ex
         throwInvalidInput(fieldPath, expectedTy, `expected ${expectedLen} elements, got ${passedV.length}`);
     }
 }
-
-export function checkIsObject(fieldPath: string, expectedTy: Ty, passedV: any, allowNull = false): void {
+function checkIsObject(fieldPath, expectedTy, passedV, allowNull = false) {
     let isObject = typeof passedV === 'object' && !Array.isArray(passedV);
     if (passedV === null && !allowNull) {
         isObject = false;
@@ -46,8 +48,7 @@ export function checkIsObject(fieldPath: string, expectedTy: Ty, passedV: any, a
         throwInvalidInput(fieldPath, expectedTy, 'not an object');
     }
 }
-
-export function checkIsObjectWithProperty(fieldPath: string, expectedTy: Ty, passedV: any, propertyName: string): void {
+function checkIsObjectWithProperty(fieldPath, expectedTy, passedV, propertyName) {
     let isObject = typeof passedV === 'object' && !Array.isArray(passedV) && passedV !== null;
     if (!isObject || !passedV.hasOwnProperty(propertyName)) {
         throwInvalidInput(fieldPath, expectedTy, `not an object with property ${propertyName}`);

package/dist/emit-field-defs.d.ts

@@ -0,0 +1,5 @@
+import { ABIConstExpression, Ty } from './abi-types';
+import { CodegenCtx } from './codegen-ctx';
+export declare function isDefaultValueSupported(fieldTy: Ty): boolean;
+export declare function emitFieldDefault(ctx: CodegenCtx, expr: ABIConstExpression): string;
+export declare function emitFieldDefaultInComment(expr: ABIConstExpression): string;

package/dist/emit-field-defs.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefaultValueSupported = isDefaultValueSupported;
+exports.emitFieldDefault = emitFieldDefault;
+exports.emitFieldDefaultInComment = emitFieldDefaultInComment;
+const formatting_1 = require("./formatting");
+const types_kernel_1 = require("./types-kernel");
+// Default values of struct fields are also exported to TypeScript unless they are hard to be represented.
+// In practice, all simple values are okay: `f: int = 5`, `f: coins = ton("1")`, etc.
+// But in theory, a field can be a union, for example. It will require a large amount of work to support
+// cases like `f: int8 | slice = 5` or `f: int32 | int64 = 5 as int64` (to generate correct `$` labels).
+// So, if such a field exists, then we just assume it has no default.
+function isDefaultValueSupported(fieldTy) {
+    if (fieldTy.kind === 'arrayOf')
+        return isDefaultValueSupported(fieldTy.inner);
+    if (fieldTy.kind === 'lispListOf')
+        return isDefaultValueSupported(fieldTy.inner);
+    if (fieldTy.kind === 'tensor')
+        return fieldTy.items.every(isDefaultValueSupported);
+    if (fieldTy.kind === 'shapedTuple')
+        return fieldTy.items.every(isDefaultValueSupported);
+    return fieldTy.kind !== 'union' && fieldTy.kind !== 'mapKV';
+}
+// Default values of fields (particularly, in storage) are precalculated by the compiler
+// and stored as "const expression" intermediate representation in ABI.
+// Here we output them to a valid TypeScript expression.
+// Default parameters for get methods follow the same logic, they are also "const expressions".
+function emitFieldDefault(ctx, expr) {
+    switch (expr.kind) {
+        case 'int': return expr.v + 'n';
+        case 'bool': return expr.v ? 'true' : 'false';
+        case 'slice': return `new c.Slice(new c.BitReader(new c.BitString(Buffer.from('${expr.hex}', 'hex'), 0, ${expr.hex.length * 4})), [])`;
+        case 'string': return JSON.stringify(expr.str);
+        case 'address': return `c.Address.parse('${expr.addr}')`;
+        case 'tensor': return `[${expr.items.map(i => emitFieldDefault(ctx, i)).join(', ')}]`;
+        case 'shapedTuple': return `[${expr.items.map(i => emitFieldDefault(ctx, i)).join(', ')}]`;
+        case 'object': {
+            const structRef = ctx.symbols.getStruct(expr.struct_name);
+            return `{ $: '${structRef.name}', ${[...structRef.fields.map((f, i) => `${(0, formatting_1.safeFieldDecl)(f.name)}: ${emitFieldDefault(ctx, expr.fields[i])}`)].join(', ')} }`;
+        }
+        case 'castTo': return emitFieldDefault(ctx, expr.inner);
+        case 'null': return `null`;
+    }
+}
+// Output a default value not as a TypeScript expression, but as a human-readable one.
+// For instance, "123" instead of bigint "123n".
+// It's inserted inside comments next to fields having defaults.
+function emitFieldDefaultInComment(expr) {
+    switch (expr.kind) {
+        case 'int': return expr.v;
+        case 'bool': return expr.v ? 'true' : 'false';
+        case 'slice': return `hex('${expr.hex}')`;
+        case 'string': return JSON.stringify(expr.str);
+        case 'address': return `address('${expr.addr}')`;
+        case 'tensor': return `[${expr.items.map(emitFieldDefaultInComment).join(', ')}]`;
+        case 'shapedTuple': return `[${expr.items.map(emitFieldDefaultInComment).join(', ')}]`;
+        case 'object': return `${expr.struct_name} { ${expr.fields.map(emitFieldDefaultInComment).join(', ')} }`;
+        case 'castTo': return `${emitFieldDefaultInComment(expr.inner)} as ${(0, types_kernel_1.renderTy)(expr.cast_to)}`;
+        case 'null': return `null`;
+    }
+}

package/dist/emit-pack-unpack.d.ts

@@ -0,0 +1,9 @@
+import type { Ty } from './abi-types';
+import { CodegenCtx } from './codegen-ctx';
+export declare function emitLoadExpr(ctx: CodegenCtx, fieldPath: string, ty: Ty): string;
+export declare function emitLoadCallback(ctx: CodegenCtx, fieldPath: string, ty: Ty): string;
+export declare function emitStoreStatement(ctx: CodegenCtx, tsExpr: string, ty: Ty): string;
+export declare function emitStoreCallback(ctx: CodegenCtx, ty: Ty): string;
+export declare function emitMakeCellFromExpr(ctx: CodegenCtx, tsExpr: string, ty: Ty, disableShortHand?: boolean): string;
+export declare function emitCallToCreateMethodExpr(ctx: CodegenCtx, bodyArg: string, ty: Ty): string;
+export declare function emitDictKVSerializers(ctx: CodegenCtx, fieldPath: string, tyK: Ty, tyV: Ty): string;