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

package/dist/dynamic-serialization.js

@@ -43,6 +43,7 @@ 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");
+const emit_ts_types_1 = require("./emit-ts-types");
 /*
     Dynamic serialization works without generating TypeScript wrappers.
     Just given an ABI, serialize any JS input to a cell, and unpack back.
@@ -55,95 +56,97 @@ const types_kernel_1 = require("./types-kernel");
 function lookupPrefix(s, expected, prefixLen) {
     return s.remainingBits >= prefixLen && s.preloadUint(prefixLen) === expected;
 }
-function createTonCoreDictionaryKey(fieldPath, tyK) {
+function createTonCoreDictionaryKey(ctx, fieldPath, tyKIdx) {
+    const tyK = ctx.symbols.tyByIdx(tyKIdx);
     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`);
+    throw new unsupported_errors_1.NonStandardDictKey(`'${fieldPath}' is 'map<${(0, types_kernel_1.renderTy)(ctx.symbols, tyKIdx)}, ...>': such a non-standard map key can not be handled by @ton/core library`);
 }
-function createTonCoreDictionaryValue(ctx, fieldPath, tyV) {
+function createTonCoreDictionaryValue(ctx, fieldPath, tyVIdx) {
     return {
         serialize(self, b) {
-            dynamicPack(ctx, fieldPath, tyV, self, b);
+            dynamicPack(ctx, fieldPath, tyVIdx, self, b);
         },
         parse(s) {
-            return dynamicUnpack(ctx, fieldPath, tyV, s);
+            return dynamicUnpack(ctx, fieldPath, tyVIdx, s);
         }
     };
 }
 // Parameter `fieldPath` is used for error messages only, e.g. when provided invalid input.
-function dynamicPack(ctx, fieldPath, ty, v, b) {
+function dynamicPack(ctx, fieldPath, tyIdx, v, b, uLabelTyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'intN': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsNumber)(ctx, fieldPath, tyIdx, v);
             b.storeInt(v, ty.n);
             break;
         }
         case 'uintN': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsNumber)(ctx, fieldPath, tyIdx, v);
             b.storeUint(v, ty.n);
             break;
         }
         case 'varintN': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsNumber)(ctx, fieldPath, tyIdx, v);
             b.storeVarInt(v, Math.log2(ty.n));
             break;
         }
         case 'varuintN': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsNumber)(ctx, fieldPath, tyIdx, v);
             b.storeVarUint(v, Math.log2(ty.n));
             break;
         }
         case 'coins': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsNumber)(ctx, fieldPath, tyIdx, v);
             b.storeCoins(v);
             break;
         }
         case 'bool': {
-            (0, dynamic_validation_1.checkIsBoolean)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsBoolean)(ctx, fieldPath, tyIdx, v);
             b.storeBit(v);
             break;
         }
         case 'cell': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
             b.storeRef(v);
             break;
         }
         case 'builder': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
             b.storeBuilder(v);
             break;
         }
         case 'slice': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
             b.storeSlice(v);
             break;
         }
         case 'string': {
-            (0, dynamic_validation_1.checkIsString)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsString)(ctx, fieldPath, tyIdx, v);
             b.storeStringRefTail(v);
             break;
         }
         case 'remaining': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
             b.storeSlice(v);
             break;
         }
         case 'address': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
             b.storeAddress(v);
             break;
         }
         case 'addressOpt': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v, true);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v, true);
             b.storeAddress(v);
             break;
         }
         case 'addressExt': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
             b.storeAddress(v);
             break;
         }
@@ -152,15 +155,15 @@ function dynamicPack(ctx, fieldPath, ty, v, b) {
                 b.storeAddress(null);
             }
             else {
-                (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+                (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
                 b.storeAddress(v);
             }
             break;
         }
         case 'bitsN': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, 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`);
+                (0, dynamic_validation_1.throwInvalidInput)(ctx, fieldPath, tyIdx, `expected ${ty.n} bits and 0 refs, got ${v.remainingBits} bits and ${v.remainingRefs} refs`);
             }
             b.storeSlice(v);
             break;
@@ -171,24 +174,24 @@ function dynamicPack(ctx, fieldPath, ty, v, b) {
             }
             else {
                 b.storeUint(1, 1);
-                dynamicPack(ctx, fieldPath, ty.inner, v, b);
+                dynamicPack(ctx, fieldPath, ty.inner_ty_idx, v, b);
             }
             break;
         }
         case 'cellOf': {
-            (0, dynamic_validation_1.checkIsObjectWithProperty)(fieldPath, ty, v, 'ref');
+            (0, dynamic_validation_1.checkIsObjectWithProperty)(ctx, fieldPath, tyIdx, v, 'ref');
             let b_ref = c.beginCell();
-            dynamicPack(ctx, fieldPath, ty.inner, v.ref, b_ref);
+            dynamicPack(ctx, fieldPath, ty.inner_ty_idx, v.ref, b_ref);
             b.storeRef(b_ref.endCell());
             break;
         }
         case 'arrayOf': {
-            (0, dynamic_validation_1.checkIsArray)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsArray)(ctx, fieldPath, tyIdx, 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);
+                dynamicPack(ctx, fieldPath + '[ith]', ty.inner_ty_idx, v[v.length - 1 - i], chunkB);
                 tail = chunkB.endCell();
             }
             b.storeUint(v.length, 8);
@@ -196,11 +199,11 @@ function dynamicPack(ctx, fieldPath, ty, v, b) {
             break;
         }
         case 'lispListOf': {
-            (0, dynamic_validation_1.checkIsArray)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsArray)(ctx, fieldPath, tyIdx, 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);
+                dynamicPack(ctx, `${fieldPath}[${i}]`, ty.inner_ty_idx, v[i], itemB);
                 tail = itemB.storeRef(tail).endCell();
             }
             b.storeRef(tail);
@@ -208,50 +211,49 @@ function dynamicPack(ctx, fieldPath, ty, v, b) {
         }
         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);
+            (0, dynamic_validation_1.checkIsArray)(ctx, fieldPath, tyIdx, v, ty.items_ty_idx.length);
             for (let i = 0; i < v.length; ++i) {
-                dynamicPack(ctx, `${fieldPath}[${i}]`, ty.items[i], v[i], b);
+                dynamicPack(ctx, `${fieldPath}[${i}]`, ty.items_ty_idx[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);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
+            let dictKey = createTonCoreDictionaryKey(ctx, fieldPath, ty.key_ty_idx);
+            let dictValue = createTonCoreDictionaryValue(ctx, fieldPath, ty.value_ty_idx);
             b.storeDict(v, dictKey, dictValue);
             break;
         }
         case 'EnumRef': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsNumber)(ctx, fieldPath, tyIdx, 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);
+            dynamicPack(ctx, fieldPath, enumRef.encoded_as_ty_idx, v, b);
             break;
         }
         case 'StructRef': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, 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);
+                b.storeUint(structRef.prefix.prefix_num, 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;
+            for (let f of ctx.symbols.structFieldsOf(tyIdx)) {
                 try {
-                    dynamicPack(ctx, `${fieldPath}.${f.name}`, fTy, v[f.name], b);
+                    dynamicPack(ctx, `${fieldPath}.${f.name}`, f.ty_idx, v[f.name], b, f.uLabelTyIdx);
                 }
                 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());
+                    (0, dynamic_validation_1.throwInvalidInput)(ctx, `${fieldPath}.${f.name}`, f.ty_idx, ex.message ?? ex.toString());
                 }
             }
             break;
@@ -262,41 +264,42 @@ function dynamicPack(ctx, fieldPath, ty, v, b) {
                 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);
+            const target = ctx.symbols.aliasTargetOf(tyIdx);
+            dynamicPack(ctx, fieldPath, target.ty_idx, v, b, target.uLabelTyIdx);
             break;
         }
         case 'union': {
-            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
-            const hasNull = variants.find(v => v.variant_ty.kind === 'nullLiteral');
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants, uLabelTyIdx);
+            const hasNull = variants.find(v => ctx.symbols.tyByIdx(v.variant_ty_idx).kind === 'nullLiteral');
             if (hasNull && v === null) {
-                b.storeUint(+hasNull.prefix_str, hasNull.prefix_len);
+                b.storeUint(hasNull.prefix_num, hasNull.prefix_len);
             }
             else {
-                (0, dynamic_validation_1.checkIsObjectWithProperty)(fieldPath, ty, v, '$');
+                (0, dynamic_validation_1.checkIsObjectWithProperty)(ctx, fieldPath, tyIdx, v, '$');
                 const activeVariant = variants.find(variant => v.$ === variant.labelStr);
                 if (!activeVariant) {
-                    (0, dynamic_validation_1.throwInvalidInput)(fieldPath, ty, `non-existing union variant for $ = '${v.$}'`);
+                    (0, dynamic_validation_1.throwInvalidInput)(ctx, fieldPath, tyIdx, `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`);
+                    (0, dynamic_validation_1.throwInvalidInput)(ctx, fieldPath, tyIdx, `expected {$,value} but field 'value' not provided`);
                 }
                 if (activeVariant.is_prefix_implicit) {
-                    b.storeUint(+activeVariant.prefix_str, activeVariant.prefix_len);
+                    b.storeUint(activeVariant.prefix_num, activeVariant.prefix_len);
                 }
                 let actualValue = activeVariant.hasValueField ? v.value : v;
-                dynamicPack(ctx, `${fieldPath}#${activeVariant.labelStr}`, activeVariant.variant_ty, actualValue, b);
+                dynamicPack(ctx, `${fieldPath}#${activeVariant.labelStr}`, activeVariant.variant_ty_idx, actualValue, b);
             }
             break;
         }
         case 'void':
             break;
         default:
-            throw new unsupported_errors_1.CantPackDynamic(fieldPath, `type '${(0, types_kernel_1.renderTy)(ty)}' is not serializable`);
+            throw new unsupported_errors_1.CantPackDynamic(fieldPath, `type '${(0, types_kernel_1.renderTy)(ctx.symbols, tyIdx)}' 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) {
+function dynamicUnpack(ctx, fieldPath, tyIdx, s, uLabelTyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'intN': return s.loadIntBig(ty.n);
         case 'uintN': return s.loadUintBig(ty.n);
@@ -323,10 +326,10 @@ function dynamicUnpack(ctx, fieldPath, ty, s) {
         }
         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 'nullable': return s.loadBoolean() ? dynamicUnpack(ctx, fieldPath, ty.inner_ty_idx, s) : null;
         case 'cellOf': {
             let s_ref = s.loadRef().beginParse();
-            return { ref: dynamicUnpack(ctx, fieldPath, ty.inner, s_ref) };
+            return { ref: dynamicUnpack(ctx, fieldPath, ty.inner_ty_idx, s_ref) };
         }
         case 'arrayOf': {
             let len = s.loadUint(8);
@@ -336,7 +339,7 @@ function dynamicUnpack(ctx, fieldPath, ty, s) {
                 let s = head.beginParse();
                 head = s.loadMaybeRef();
                 while (s.remainingBits || s.remainingRefs) {
-                    outArr.push(dynamicUnpack(ctx, fieldPath + '[ith]', ty.inner, s));
+                    outArr.push(dynamicUnpack(ctx, fieldPath + '[ith]', ty.inner_ty_idx, s));
                 }
             }
             if (len !== outArr.length) {
@@ -349,7 +352,7 @@ function dynamicUnpack(ctx, fieldPath, ty, s) {
             let head = s.loadRef().beginParse();
             while (head.remainingRefs) {
                 let tailSnaked = head.loadRef();
-                let headValue = dynamicUnpack(ctx, fieldPath + '[ith]', ty.inner, head);
+                let headValue = dynamicUnpack(ctx, fieldPath + '[ith]', ty.inner_ty_idx, head);
                 head.endParse(); // ensure no data is present besides T
                 outArr.unshift(headValue);
                 head = tailSnaked.beginParse();
@@ -358,11 +361,11 @@ function dynamicUnpack(ctx, fieldPath, ty, s) {
         }
         case 'tensor':
         case 'shapedTuple': {
-            return ty.items.map((item, idx) => dynamicUnpack(ctx, `${fieldPath}[${idx}]`, item, s));
+            return ty.items_ty_idx.map((ty_idx, idx) => dynamicUnpack(ctx, `${fieldPath}[${idx}]`, ty_idx, s));
         }
         case 'mapKV': {
-            let dictKey = createTonCoreDictionaryKey(fieldPath, ty.k);
-            let dictValue = createTonCoreDictionaryValue(ctx, fieldPath, ty.v);
+            let dictKey = createTonCoreDictionaryKey(ctx, fieldPath, ty.key_ty_idx);
+            let dictValue = createTonCoreDictionaryValue(ctx, fieldPath, ty.value_ty_idx);
             return s.loadDict(dictKey, dictValue);
         }
         case 'EnumRef': {
@@ -370,7 +373,7 @@ function dynamicUnpack(ctx, fieldPath, ty, s) {
             if (enumRef.custom_pack_unpack?.unpack_from_slice) {
                 return ctx.getCustomUnpackFnOrThrow(ty.enum_name, fieldPath)(s);
             }
-            return dynamicUnpack(ctx, fieldPath, enumRef.encoded_as, s);
+            return dynamicUnpack(ctx, fieldPath, enumRef.encoded_as_ty_idx, s);
         }
         case 'StructRef': {
             let structRef = ctx.symbols.getStruct(ty.struct_name);
@@ -380,14 +383,13 @@ function dynamicUnpack(ctx, fieldPath, ty, 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}`);
+                if (prefix !== structRef.prefix.prefix_num) {
+                    throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, `incorrect prefix for '${ty.struct_name}', expected ${(0, emit_ts_types_1.emitPrefixHex)(structRef.prefix)}`);
                 }
             }
-            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;
+            for (let f of ctx.symbols.structFieldsOf(tyIdx)) {
                 try {
-                    result[f.name] = dynamicUnpack(ctx, `${fieldPath}.${f.name}`, fTy, s);
+                    result[f.name] = dynamicUnpack(ctx, `${fieldPath}.${f.name}`, f.ty_idx, s, f.uLabelTyIdx);
                 }
                 catch (ex) {
                     if (ex instanceof unsupported_errors_1.CantUnpackDynamic) {
@@ -404,19 +406,19 @@ function dynamicUnpack(ctx, fieldPath, ty, s) {
             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);
+            const target = ctx.symbols.aliasTargetOf(tyIdx);
+            return dynamicUnpack(ctx, fieldPath, target.ty_idx, s, target.uLabelTyIdx);
         }
-        case 'genericT': throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, 'unexpected genericT');
+        case 'genericT': throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, `unexpected genericT at ${fieldPath}`);
         case 'union': {
-            for (const variant of (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants)) {
-                if (!lookupPrefix(s, +variant.prefix_str, variant.prefix_len)) {
+            for (const variant of (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants, uLabelTyIdx)) {
+                if (!lookupPrefix(s, variant.prefix_num, 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);
+                let actualValue = dynamicUnpack(ctx, `${fieldPath}#${variant.labelStr}`, variant.variant_ty_idx, s);
                 if (!variant.hasValueField) {
                     return actualValue;
                 }
@@ -427,27 +429,29 @@ function dynamicUnpack(ctx, fieldPath, ty, s) {
         case 'void':
             return void 0;
         default:
-            throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, `type '${(0, types_kernel_1.renderTy)(ty)}' is not serializable`);
+            throw new unsupported_errors_1.CantUnpackDynamic(fieldPath, `type '${(0, types_kernel_1.renderTy)(ctx.symbols, tyIdx)}' 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.
+ * Call: `packToBuilderDynamic(ctx, pointTyIdx, { 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) {
+function packToBuilderDynamic(ctx, tyIdx, value, b) {
+    let ty = ctx.symbols.tyByIdx(tyIdx);
     let fieldPath = ty.kind === 'StructRef' ? ty.struct_name : 'self';
-    dynamicPack(ctx, fieldPath, ty, value, b);
+    dynamicPack(ctx, fieldPath, tyIdx, 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 }`.
+ * Call: `unpackFromSliceDynamic(ctx, pointTyIdx, hex"0A14")` returns `{ x: 10, y: 20 }`.
  * When ty can't be deserialized, throws CantUnpackDynamic.
  */
-function unpackFromSliceDynamic(ctx, ty, s) {
+function unpackFromSliceDynamic(ctx, tyIdx, s) {
+    let ty = ctx.symbols.tyByIdx(tyIdx);
     let fieldPath = ty.kind === 'StructRef' ? ty.struct_name : 'self';
-    return dynamicUnpack(ctx, fieldPath, ty, s);
+    return dynamicUnpack(ctx, fieldPath, tyIdx, s);
 }

package/dist/dynamic-validation.d.ts

@@ -1,8 +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;
+import { DynamicCtx } from './dynamic-ctx';
+export declare function throwInvalidInput(ctx: DynamicCtx, fieldPath: string, expectedTyIdx: number, msgWhyInvalid: string): never;
+export declare function checkIsNumber(ctx: DynamicCtx, fieldPath: string, expectedTyIdx: number, passedV: any): void;
+export declare function checkIsBoolean(ctx: DynamicCtx, fieldPath: string, expectedTyIdx: number, passedV: any): void;
+export declare function checkIsString(ctx: DynamicCtx, fieldPath: string, expectedTyIdx: number, passedV: any): void;
+export declare function checkIsArray(ctx: DynamicCtx, fieldPath: string, expectedTyIdx: number, passedV: any, expectedLen?: number): void;
+export declare function checkIsObject(ctx: DynamicCtx, fieldPath: string, expectedTyIdx: number, passedV: any, allowNull?: boolean): void;
+export declare function checkIsObjectWithProperty(ctx: DynamicCtx, fieldPath: string, expectedTyIdx: number, passedV: any, propertyName: string): void;

package/dist/dynamic-validation.js

@@ -9,48 +9,48 @@ 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}`);
+function throwInvalidInput(ctx, fieldPath, expectedTyIdx, msgWhyInvalid) {
+    throw new unsupported_errors_1.InvalidDynamicInput(`invalid value passed for '${fieldPath}' of type '${(0, types_kernel_1.renderTy)(ctx.symbols, expectedTyIdx)}': ${msgWhyInvalid}`);
 }
-function checkIsNumber(fieldPath, expectedTy, passedV) {
+function checkIsNumber(ctx, fieldPath, expectedTyIdx, passedV) {
     let isNumber = typeof passedV === 'bigint' || typeof passedV === 'number';
     if (!isNumber) {
-        throwInvalidInput(fieldPath, expectedTy, 'not a number');
+        throwInvalidInput(ctx, fieldPath, expectedTyIdx, 'not a number');
     }
 }
-function checkIsBoolean(fieldPath, expectedTy, passedV) {
+function checkIsBoolean(ctx, fieldPath, expectedTyIdx, passedV) {
     let isBoolean = typeof passedV === 'boolean';
     if (!isBoolean) {
-        throwInvalidInput(fieldPath, expectedTy, 'not a boolean');
+        throwInvalidInput(ctx, fieldPath, expectedTyIdx, 'not a boolean');
     }
 }
-function checkIsString(fieldPath, expectedTy, passedV) {
+function checkIsString(ctx, fieldPath, expectedTyIdx, passedV) {
     let isString = typeof passedV === 'string';
     if (!isString) {
-        throwInvalidInput(fieldPath, expectedTy, 'not a string');
+        throwInvalidInput(ctx, fieldPath, expectedTyIdx, 'not a string');
     }
 }
-function checkIsArray(fieldPath, expectedTy, passedV, expectedLen) {
+function checkIsArray(ctx, fieldPath, expectedTyIdx, passedV, expectedLen) {
     let isArray = Array.isArray(passedV);
     if (!isArray) {
-        throwInvalidInput(fieldPath, expectedTy, 'not an array');
+        throwInvalidInput(ctx, fieldPath, expectedTyIdx, 'not an array');
     }
     if (expectedLen !== undefined && passedV.length !== expectedLen) {
-        throwInvalidInput(fieldPath, expectedTy, `expected ${expectedLen} elements, got ${passedV.length}`);
+        throwInvalidInput(ctx, fieldPath, expectedTyIdx, `expected ${expectedLen} elements, got ${passedV.length}`);
     }
 }
-function checkIsObject(fieldPath, expectedTy, passedV, allowNull = false) {
+function checkIsObject(ctx, fieldPath, expectedTyIdx, passedV, allowNull = false) {
     let isObject = typeof passedV === 'object' && !Array.isArray(passedV);
     if (passedV === null && !allowNull) {
         isObject = false;
     }
     if (!isObject) {
-        throwInvalidInput(fieldPath, expectedTy, 'not an object');
+        throwInvalidInput(ctx, fieldPath, expectedTyIdx, 'not an object');
     }
 }
-function checkIsObjectWithProperty(fieldPath, expectedTy, passedV, propertyName) {
+function checkIsObjectWithProperty(ctx, fieldPath, expectedTyIdx, 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}`);
+        throwInvalidInput(ctx, fieldPath, expectedTyIdx, `not an object with property ${propertyName}`);
     }
 }

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

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

package/dist/emit-field-defs.js

@@ -10,15 +10,16 @@ const types_kernel_1 = require("./types-kernel");
 // 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) {
+function isDefaultValueSupported(ctx, fieldTyIdx) {
+    const fieldTy = ctx.symbols.tyByIdx(fieldTyIdx);
     if (fieldTy.kind === 'arrayOf')
-        return isDefaultValueSupported(fieldTy.inner);
+        return isDefaultValueSupported(ctx, fieldTy.inner_ty_idx);
     if (fieldTy.kind === 'lispListOf')
-        return isDefaultValueSupported(fieldTy.inner);
+        return isDefaultValueSupported(ctx, fieldTy.inner_ty_idx);
     if (fieldTy.kind === 'tensor')
-        return fieldTy.items.every(isDefaultValueSupported);
+        return fieldTy.items_ty_idx.every(ty_idx => isDefaultValueSupported(ctx, ty_idx));
     if (fieldTy.kind === 'shapedTuple')
-        return fieldTy.items.every(isDefaultValueSupported);
+        return fieldTy.items_ty_idx.every(ty_idx => isDefaultValueSupported(ctx, ty_idx));
     return fieldTy.kind !== 'union' && fieldTy.kind !== 'mapKV';
 }
 // Default values of fields (particularly, in storage) are precalculated by the compiler
@@ -45,17 +46,17 @@ function emitFieldDefault(ctx, expr) {
 // 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) {
+function emitFieldDefaultInComment(ctx, 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 'tensor': return `[${expr.items.map(i => emitFieldDefaultInComment(ctx, i)).join(', ')}]`;
+        case 'shapedTuple': return `[${expr.items.map(i => emitFieldDefaultInComment(ctx, i)).join(', ')}]`;
+        case 'object': return `${expr.struct_name} { ${expr.fields.map(i => emitFieldDefaultInComment(ctx, i)).join(', ')} }`;
+        case 'castTo': return `${emitFieldDefaultInComment(ctx, expr.inner)} as ${(0, types_kernel_1.renderTy)(ctx.symbols, expr.cast_to_ty_idx)}`;
         case 'null': return `null`;
     }
 }

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

@@ -1,9 +1,15 @@
-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;
+import { ABIAlias, ABIEnum, ABIStruct } from './abi-types';
+export declare function emitLoadOfStruct(ctx: CodegenCtx, structRef: ABIStruct, instantiationTyIdx: number): string;
+export declare function emitLoadOfAlias(ctx: CodegenCtx, aliasRef: ABIAlias, instantiationTyIdx: number): string;
+export declare function emitLoadOfEnum(ctx: CodegenCtx, enumRef: ABIEnum): string;
+export declare function emitLoadExpr(ctx: CodegenCtx, fieldPath: string, tyIdx: number, uLabelTyIdx?: number): string;
+export declare function emitLoadCallback(ctx: CodegenCtx, fieldPath: string, tyIdx: number): string;
+export declare function emitStoreOfStruct(ctx: CodegenCtx, tsExpr: string, structRef: ABIStruct, instantiationTyIdx: number): string;
+export declare function emitStoreOfAlias(ctx: CodegenCtx, tsExpr: string, aliasRef: ABIAlias, instantiationTyIdx: number): string;
+export declare function emitStoreOfEnum(ctx: CodegenCtx, tsExpr: string, enumRef: ABIEnum): string;
+export declare function emitStoreStatement(ctx: CodegenCtx, tsExpr: string, tyIdx: number, uLabelTyIdx?: number): string;
+export declare function emitStoreCallback(ctx: CodegenCtx, tyIdx: number): string;
+export declare function emitMakeCellFromExpr(ctx: CodegenCtx, tsExpr: string, tyIdx: number, disableShortHand?: boolean): string;
+export declare function emitCallToCreateMethodExpr(ctx: CodegenCtx, bodyArg: string, tyIdx: number): string;
+export declare function emitDictKVSerializers(ctx: CodegenCtx, fieldPath: string, tyKIdx: number, tyVIdx: number): string;