gen-typescript-from-tolk-dev 0.2.3 → 0.3.0

package/dist/dynamic-get-methods.js

@@ -168,20 +168,21 @@ class StackReader {
 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) {
+function makeCell(ctx, fieldPath, tyIdx, v, uLabelTyIdx) {
     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
+    (0, dynamic_serialization_1.dynamicPack)(ctx, fieldPath, tyIdx, v, b, uLabelTyIdx); // 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) {
+function dynamicConstruct(ctx, fieldPath, tyIdx, v, tupleIfW = false, uLabelTyIdx) {
     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);
+        if ((0, types_kernel_1.calcWidthOnStack)(ctx.symbols, tyIdx) === 1) {
+            return dynamicConstruct(ctx, fieldPath, tyIdx, v, false, uLabelTyIdx);
         }
-        return [{ type: 'tuple', items: dynamicConstruct(ctx, fieldPath, ty, v, false) }];
+        return [{ type: 'tuple', items: dynamicConstruct(ctx, fieldPath, tyIdx, v, false, uLabelTyIdx) }];
     }
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'int':
         case 'intN':
@@ -189,20 +190,20 @@ function dynamicConstruct(ctx, fieldPath, ty, v, tupleIfW = false) {
         case 'varintN':
         case 'varuintN':
         case 'coins': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsNumber)(ctx, fieldPath, tyIdx, v);
             return [{ type: 'int', value: v }];
         }
         case 'bool': {
-            (0, dynamic_validation_1.checkIsBoolean)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsBoolean)(ctx, fieldPath, tyIdx, v);
             return [{ type: 'int', value: (v ? -1n : 0n) }];
         }
         case 'cell': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, 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) }];
+            return [{ type: 'builder', cell: makeCell(ctx, fieldPath, tyIdx, v, uLabelTyIdx) }];
         }
         case 'slice':
         case 'remaining':
@@ -210,28 +211,28 @@ function dynamicConstruct(ctx, fieldPath, ty, v, tupleIfW = false) {
         case 'addressExt':
         case 'addressAny':
         case 'bitsN': {
-            return [{ type: 'slice', cell: makeCell(ctx, fieldPath, ty, v) }];
+            return [{ type: 'slice', cell: makeCell(ctx, fieldPath, tyIdx, v, uLabelTyIdx) }];
         }
         case 'string': {
-            return [{ type: 'cell', cell: makeCell(ctx, fieldPath, ty, v) }];
+            return [{ type: 'cell', cell: makeCell(ctx, fieldPath, tyIdx, v, uLabelTyIdx) }];
         }
         case 'addressOpt': {
             if (v === null) {
                 return [{ type: 'null' }];
             }
-            return [{ type: 'slice', cell: makeCell(ctx, fieldPath, ty, v) }];
+            return [{ type: 'slice', cell: makeCell(ctx, fieldPath, tyIdx, v, uLabelTyIdx) }];
         }
         case 'nullLiteral': {
             return [{ type: 'null' }];
         }
         case 'callable': {
-            throw new unsupported_errors_1.NotSupportedTypeOnStack(ty, fieldPath);
+            throw new unsupported_errors_1.NotSupportedTypeOnStack((0, types_kernel_1.renderTy)(ctx.symbols, tyIdx), fieldPath);
         }
         case 'void': {
             return [];
         }
         case 'unknown': {
-            (0, dynamic_validation_1.checkIsObjectWithProperty)(fieldPath, ty, v, 'type'); // c.TupleItem has 'type'
+            (0, dynamic_validation_1.checkIsObjectWithProperty)(ctx, fieldPath, tyIdx, v, 'type'); // c.TupleItem has 'type'
             return [v];
         }
         case 'nullable': {
@@ -244,7 +245,7 @@ function dynamicConstruct(ctx, fieldPath, ty, v, tupleIfW = false) {
                     result.push({ type: 'int', value: 0n });
                 }
                 else {
-                    result = dynamicConstruct(ctx, fieldPath, ty.inner, v);
+                    result = dynamicConstruct(ctx, fieldPath, ty.inner_ty_idx, v);
                     result.push({ type: 'int', value: BigInt(ty.stack_type_id) });
                 }
                 return result;
@@ -252,57 +253,55 @@ function dynamicConstruct(ctx, fieldPath, ty, v, tupleIfW = false) {
             if (v === null) {
                 return [{ type: 'null' }];
             }
-            return dynamicConstruct(ctx, fieldPath, ty.inner, v);
+            return dynamicConstruct(ctx, fieldPath, ty.inner_ty_idx, v);
         }
         case 'cellOf': {
-            (0, dynamic_validation_1.checkIsObjectWithProperty)(fieldPath, ty, v, 'ref');
-            return [{ type: 'cell', cell: makeCell(ctx, fieldPath, ty.inner, v.ref) }];
+            (0, dynamic_validation_1.checkIsObjectWithProperty)(ctx, fieldPath, tyIdx, v, 'ref');
+            return [{ type: 'cell', cell: makeCell(ctx, fieldPath, ty.inner_ty_idx, 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]) }];
+            (0, dynamic_validation_1.checkIsArray)(ctx, fieldPath, tyIdx, v);
+            return [{ type: 'tuple', items: v.map((ith) => dynamicConstruct(ctx, 'ith', ty.inner_ty_idx, 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' })];
+            (0, dynamic_validation_1.checkIsArray)(ctx, fieldPath, tyIdx, v);
+            return [v.reduceRight((tail, head) => ({ type: 'tuple', items: [dynamicConstruct(ctx, 'head', ty.inner_ty_idx, 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));
+            (0, dynamic_validation_1.checkIsArray)(ctx, fieldPath, tyIdx, v, ty.items_ty_idx.length);
+            return v.flatMap((item, idx) => dynamicConstruct(ctx, `${fieldPath}[${idx}]`, ty.items_ty_idx[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]) }];
+            (0, dynamic_validation_1.checkIsArray)(ctx, fieldPath, tyIdx, v, ty.items_ty_idx.length);
+            return [{ type: 'tuple', items: v.map((ith, idx) => dynamicConstruct(ctx, `${fieldPath}[${idx}]`, ty.items_ty_idx[idx], ith, true)[0]) }];
         }
         case 'mapKV': {
-            (0, dynamic_validation_1.checkIsObject)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, 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);
+            let dictKey = (0, dynamic_serialization_1.createTonCoreDictionaryKey)(ctx, fieldPath, ty.key_ty_idx);
+            let dictValue = (0, dynamic_serialization_1.createTonCoreDictionaryValue)(ctx, fieldPath, ty.value_ty_idx);
             return [{ type: 'cell', cell: c.beginCell().storeDictDirect(v, dictKey, dictValue).endCell() }];
         }
         case 'EnumRef': {
-            (0, dynamic_validation_1.checkIsNumber)(fieldPath, ty, v);
+            (0, dynamic_validation_1.checkIsNumber)(ctx, fieldPath, tyIdx, 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]);
-            });
+            (0, dynamic_validation_1.checkIsObject)(ctx, fieldPath, tyIdx, v);
+            return ctx.symbols.structFieldsOf(tyIdx).flatMap(f => dynamicConstruct(ctx, `${fieldPath}.${f.name}`, f.ty_idx, v[f.name], false, f.uLabelTyIdx));
         }
         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);
+            const target = ctx.symbols.aliasTargetOf(tyIdx);
+            return dynamicConstruct(ctx, fieldPath, target.ty_idx, v, false, target.uLabelTyIdx);
         }
         case 'union': {
-            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
-            const hasNull = variants.find(v => v.variant_ty.kind === 'nullLiteral');
+            if (ty.stack_width === undefined) {
+                throw new Error(`unexpected stack_width=undefined at ${fieldPath}`);
+            }
+            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');
             let result = [];
             if (hasNull && v === null) {
                 for (let i = 0; i < ty.stack_width - 1; ++i) {
@@ -311,19 +310,19 @@ function dynamicConstruct(ctx, fieldPath, ty, v, tupleIfW = false) {
                 result.push({ type: 'int', value: 0n });
             }
             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`);
                 }
                 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(...dynamicConstruct(ctx, `${fieldPath}#${activeVariant.labelStr}`, activeVariant.variant_ty_idx, actualValue, false));
                 result.push({ type: 'int', value: BigInt(activeVariant.stack_type_id) });
             }
             return result;
@@ -333,13 +332,14 @@ function dynamicConstruct(ctx, fieldPath, ty, v, tupleIfW = false) {
 }
 // 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) {
+function dynamicParse(ctx, r, fieldPath, tyIdx, unTupleIfW = false, uLabelTyIdx) {
     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);
+        let wOnStack = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, tyIdx);
         if (wOnStack !== 1) {
-            return r.readTuple(wOnStack, (r) => dynamicParse(ctx, r, fieldPath, ty, false));
+            return r.readTuple(wOnStack, (r) => dynamicParse(ctx, r, fieldPath, tyIdx, false, uLabelTyIdx));
         }
     }
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'int':
         case 'intN':
@@ -354,66 +354,66 @@ function dynamicParse(ctx, r, fieldPath, ty, unTupleIfW = false) {
         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 'addressOpt': return r.readNullable((r) => r.readSlice().loadAddress());
         case 'addressExt': return r.readSlice().loadExternalAddress();
-        case 'addressAny': return (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, ty, r.readSlice());
+        case 'addressAny': return (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, tyIdx, r.readSlice());
         case 'bitsN': return r.readSlice();
         case 'nullLiteral': return r.readNullLiteral();
-        case 'callable': throw new unsupported_errors_1.NotSupportedTypeOnStack(ty, fieldPath);
+        case 'callable': throw new unsupported_errors_1.NotSupportedTypeOnStack((0, types_kernel_1.renderTy)(ctx.symbols, tyIdx), 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.readWideNullable(ty.stack_width, (r) => dynamicParse(ctx, r, fieldPath, ty.inner_ty_idx));
             }
-            return r.readNullable((r) => dynamicParse(ctx, r, fieldPath, ty.inner));
+            return r.readNullable((r) => dynamicParse(ctx, r, fieldPath, ty.inner_ty_idx));
         }
-        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 'cellOf': return r.readCellRef((s) => (0, dynamic_serialization_1.dynamicUnpack)(ctx, fieldPath, ty.inner_ty_idx, s));
+        case 'arrayOf': return r.readArrayOf((r) => dynamicParse(ctx, r, fieldPath, ty.inner_ty_idx, true));
+        case 'lispListOf': return r.readLispListOf((r) => dynamicParse(ctx, r, fieldPath, ty.inner_ty_idx, true));
         case 'tensor': {
             let result = [];
-            for (let i = 0; i < ty.items.length; ++i) {
-                result.push(dynamicParse(ctx, r, `${fieldPath}[${i}]`, ty.items[i]));
+            for (let i = 0; i < ty.items_ty_idx.length; ++i) {
+                result.push(dynamicParse(ctx, r, `${fieldPath}[${i}]`, ty.items_ty_idx[i]));
             }
             return result;
         }
         case 'shapedTuple': {
-            return r.readTuple(ty.items.length, (r) => {
+            return r.readTuple(ty.items_ty_idx.length, (r) => {
                 let result = [];
-                for (let i = 0; i < ty.items.length; ++i) {
-                    result.push(dynamicParse(ctx, r, `${fieldPath}[${i}]`, ty.items[i], true));
+                for (let i = 0; i < ty.items_ty_idx.length; ++i) {
+                    result.push(dynamicParse(ctx, r, `${fieldPath}[${i}]`, ty.items_ty_idx[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);
+            let dictKey = (0, dynamic_serialization_1.createTonCoreDictionaryKey)(ctx, fieldPath, ty.key_ty_idx);
+            let dictValue = (0, dynamic_serialization_1.createTonCoreDictionaryValue)(ctx, fieldPath, ty.value_ty_idx);
             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);
+            for (let f of ctx.symbols.structFieldsOf(tyIdx)) {
+                result[f.name] = dynamicParse(ctx, r, `${fieldPath}.${f.name}`, f.ty_idx, false, f.uLabelTyIdx);
             }
             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);
+            const target = ctx.symbols.aliasTargetOf(tyIdx);
+            return dynamicParse(ctx, r, fieldPath, target.ty_idx, false, target.uLabelTyIdx);
         }
         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);
+            if (ty.stack_width === undefined) {
+                throw new Error(`unexpected stack_width=undefined at ${fieldPath}`);
+            }
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants, uLabelTyIdx);
             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)
+                    (r) => dynamicParse(ctx, r, `${fieldPath}#${v.labelStr}`, v.variant_ty_idx, false)
                 ];
             }
             return r.readUnionType(ty.stack_width, infoForTypeId);
@@ -424,8 +424,8 @@ function dynamicParse(ctx, r, fieldPath, ty, unTupleIfW = false) {
  * 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);
+function makeTvmTupleDynamic(ctx, tyIdx, value) {
+    return dynamicConstruct(ctx, 'value', tyIdx, value);
 }
 /**
  * Invoke any get method taking plain JS variables as arguments and interpreting the resulting TVM tuple according to ABI.
@@ -443,9 +443,9 @@ async function callGetMethodDynamic(provider, ctx, getMethodName, args) {
     }
     const stackIn = [];
     for (let i = 0; i < args.length; ++i) {
-        stackIn.push(...dynamicConstruct(ctx, getM.parameters[i].name, getM.parameters[i].ty, args[i]));
+        stackIn.push(...dynamicConstruct(ctx, getM.parameters[i].name, getM.parameters[i].ty_idx, args[i]));
     }
-    const expectedSlotsOut = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, getM.return_ty);
+    const expectedSlotsOut = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, getM.return_ty_idx);
     const r = StackReader.fromGetMethod(expectedSlotsOut, await provider.get(getMethodName, stackIn));
-    return dynamicParse(ctx, r, 'result', getM.return_ty);
+    return dynamicParse(ctx, r, 'result', getM.return_ty_idx);
 }

package/dist/dynamic-serialization.d.ts

@@ -1,22 +1,21 @@
 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;
+export declare function createTonCoreDictionaryKey(ctx: DynamicCtx, fieldPath: string, tyKIdx: number): c.DictionaryKey<any>;
+export declare function createTonCoreDictionaryValue(ctx: DynamicCtx, fieldPath: string, tyVIdx: number): c.DictionaryValue<any>;
+export declare function dynamicPack(ctx: DynamicCtx, fieldPath: string, tyIdx: number, v: any, b: c.Builder, uLabelTyIdx?: number): void;
+export declare function dynamicUnpack(ctx: DynamicCtx, fieldPath: string, tyIdx: number, s: c.Slice, uLabelTyIdx?: number): 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.
+ * 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.
  */
-export declare function packToBuilderDynamic(ctx: DynamicCtx, ty: Ty, value: any, b: c.Builder): void;
+export declare function packToBuilderDynamic(ctx: DynamicCtx, tyIdx: number, 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 }`.
+ * Call: `unpackFromSliceDynamic(ctx, pointTyIdx, 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;
+export declare function unpackFromSliceDynamic(ctx: DynamicCtx, tyIdx: number, s: c.Slice): any;