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

package/dist/generate-ts-wrappers.js

@@ -11,22 +11,22 @@ const unsupported_errors_1 = require("./unsupported-errors");
 const types_kernel_1 = require("./types-kernel");
 const out_template_generated_1 = require("./out-template.generated");
 // Output a struct as a doc comment.
-function renderStructDocComment(s) {
+function renderStructDocComment(ctx, s) {
     const genericTs = s.type_params ? `<${s.type_params.join(', ')}>` : '';
     return [
         '/**',
-        ` > struct${s.prefix ? ` (${s.prefix.prefix_str})` : ''} ${s.name}${genericTs} {`,
-        ...s.fields.map(f => ` >     ${f.name}: ${(0, types_kernel_1.renderTy)(f.ty)}`),
+        ` > struct${s.prefix ? ` (${(0, emit_ts_types_1.emitPrefixHex)(s.prefix)})` : ''} ${s.name}${genericTs} {`,
+        ...s.fields.map(f => ` >     ${f.name}: ${(0, types_kernel_1.renderTy)(ctx.symbols, f.ty_idx)}`),
         ' > }',
         ' */'
     ].join('\n');
 }
 // Output an alias as a doc comment.
-function renderAliasDocComment(a) {
+function renderAliasDocComment(ctx, a) {
     const genericTs = a.type_params ? `<${a.type_params.join(', ')}>` : '';
     return [
         '/**',
-        ` > type ${a.name}${genericTs} = ${(0, types_kernel_1.renderTy)(a.target_ty)}`,
+        ` > type ${a.name}${genericTs} = ${(0, types_kernel_1.renderTy)(ctx.symbols, a.target_ty_idx)}`,
         ' */'
     ].join('\n');
 }
@@ -53,29 +53,26 @@ function tolkStructToTypeScript(ctx, s, buf) {
     const ps = s.type_params;
     const genericTs = ps ? `<${ps.join(', ')}>` : '';
     const structName = (0, formatting_1.safeJsIdent)(s.name);
-    const structTy = { kind: 'StructRef', struct_name: s.name, type_args: s.type_params?.map(name_t => ({ kind: 'genericT', name_t })) };
-    const loadCallbackParams = ps ? ', ' + ps.map(p => `loadFn_${p}: LoadCallback<${p}>`).join(', ') : '';
-    const storeCallbackParams = ps ? ', ' + ps.map(p => `storeFn_${p}: StoreCallback<${p}>`).join(', ') : '';
-    buf.push(renderStructDocComment(s));
+    buf.push(renderStructDocComment(ctx, s));
     buf.push(`export interface ${structName}${genericTs} {`);
     buf.push(`readonly $: '${s.name}'`);
     for (const f of s.fields) {
-        let comment = f.default_value ? ` /* = ${(0, emit_field_defs_1.emitFieldDefaultInComment)(f.default_value)} */` : '';
-        buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${(0, emit_ts_types_1.emitTsType)(ctx, f.ty)}${comment}`);
+        let comment = f.default_value ? ` /* = ${(0, emit_field_defs_1.emitFieldDefaultInComment)(ctx, f.default_value)} */` : '';
+        buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${(0, emit_ts_types_1.emitTsType)(ctx, f.ty_idx)}${comment}`);
     }
     buf.push('}');
     buf.emptyLine();
     buf.push(`export const ${structName} = {`);
     if (s.prefix) {
-        buf.push(`PREFIX: ${s.prefix.prefix_str},`);
+        buf.push(`PREFIX: ${(0, emit_ts_types_1.emitPrefixHex)(s.prefix)},`);
         buf.emptyLine();
     }
-    let argsParam = s.fields.length ? 'args: ' + structParameterNoLabel(ctx, s.name) : '';
+    let argsParam = s.fields.length ? 'args: ' + structParameterNoLabel(ctx, s.ty_idx) : '';
     buf.push(`create${genericTs}(${argsParam}): ${structName}${genericTs} {`);
     buf.push(`return {`);
     buf.push(`$: '${s.name}',`);
-    for (let f of s.fields.filter(f => f.default_value && (0, emit_field_defs_1.isDefaultValueSupported)(f.ty))) {
-        let needAsAny = f.ty.kind === 'genericT';
+    for (let f of s.fields.filter(f => f.default_value && (0, emit_field_defs_1.isDefaultValueSupported)(ctx, f.ty_idx))) {
+        let needAsAny = ctx.symbols.tyByIdx(f.ty_idx).kind === 'genericT';
         buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${(0, emit_field_defs_1.emitFieldDefault)(ctx, f.default_value)}${needAsAny ? ' as any' : ''},`);
     }
     if (s.fields.length > 0) {
@@ -83,47 +80,28 @@ function tolkStructToTypeScript(ctx, s, buf) {
     }
     buf.push('}');
     buf.push(`},`);
-    buf.push(`fromSlice${genericTs}(s: c.Slice${loadCallbackParams}): ${structName}${genericTs} {`);
-    if (s.custom_pack_unpack?.unpack_from_slice) {
-        buf.push(`return invokeCustomUnpackFromSlice<${structName}>('${s.name}', s);`);
+    if (ps) { // generic structs don't have `fromSlice` and `store`
+        buf.push('}');
+        return buf.toString();
+    }
+    buf.push(`fromSlice(s: c.Slice): ${structName} {`);
+    try {
+        buf.push((0, emit_pack_unpack_1.emitLoadOfStruct)(ctx, s, s.ty_idx));
+    }
+    catch (ex) {
+        buf.push(renderThrowCantPackUnpack(structName, ex, false));
     }
-    else
-        try {
-            const fieldsLoads = s.fields.map(f => `${(0, formatting_1.safeFieldDecl)(f.name)}: ${(0, emit_pack_unpack_1.emitLoadExpr)(ctx, `${structName}${(0, formatting_1.safeFieldRead)(f.name)}`, f.ty)},`);
-            if (s.prefix && s.prefix.prefix_len === 32) {
-                buf.push(`${codegen_ctx_1.RUNTIME.loadAndCheckPrefix32}(s, ${s.prefix.prefix_str}, '${s.name}');`);
-            }
-            else if (s.prefix) {
-                ctx.has_non32Prefixes = true;
-                buf.push(`${codegen_ctx_1.RUNTIME.loadAndCheckPrefix}(s, ${s.prefix.prefix_str}, ${s.prefix.prefix_len}, '${s.name}');`);
-            }
-            buf.push(`return {`);
-            buf.push(`$: '${s.name}',`);
-            fieldsLoads.forEach(l => buf.push(l));
-            buf.push('}');
-        }
-        catch (ex) {
-            buf.push(renderThrowCantPackUnpack(structName, ex, false));
-        }
     buf.push(`},`);
-    buf.push(`store${genericTs}(self: ${structName}${genericTs}, b: c.Builder${storeCallbackParams}): void {`);
-    if (s.custom_pack_unpack?.pack_to_builder) {
-        buf.push(`invokeCustomPackToBuilder<${structName}>('${s.name}', self, b);`);
+    buf.push(`store(self: ${structName}, b: c.Builder): void {`);
+    try {
+        buf.push((0, emit_pack_unpack_1.emitStoreOfStruct)(ctx, 'self', s, s.ty_idx));
+    }
+    catch (ex) {
+        buf.push(renderThrowCantPackUnpack(structName, ex, true));
     }
-    else
-        try {
-            const fieldsStores = s.fields.map(f => (0, emit_pack_unpack_1.emitStoreStatement)(ctx, `self${(0, formatting_1.safeFieldRead)(f.name)}`, f.ty));
-            if (s.prefix) {
-                buf.push(`b.storeUint(${s.prefix.prefix_str}, ${s.prefix.prefix_len});`);
-            }
-            fieldsStores.forEach(l => buf.push(l));
-        }
-        catch (ex) {
-            buf.push(renderThrowCantPackUnpack(structName, ex, true));
-        }
     buf.push(`},`);
-    buf.push(`toCell${genericTs}(self: ${structName}${genericTs}${storeCallbackParams}): c.Cell {`);
-    buf.push(`return ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, 'self', structTy, true)};`);
+    buf.push(`toCell(self: ${structName}): c.Cell {`);
+    buf.push(`return ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, 'self', s.ty_idx, true)};`);
     buf.push('}');
     buf.push('}');
     return buf.toString();
@@ -134,49 +112,42 @@ function tolkAliasToTypeScript(ctx, a, buf) {
     const ps = a.type_params;
     const genericTs = ps ? `<${ps.join(', ')}>` : '';
     const aliasName = (0, formatting_1.safeJsIdent)(a.name);
-    const aliasTy = { kind: 'AliasRef', alias_name: a.name, type_args: a.type_params?.map(name_t => ({ kind: 'genericT', name_t })) };
-    const loadCallbackParams = ps ? ', ' + ps.map(p => `loadFn_${p}: LoadCallback<${p}>`).join(', ') : '';
-    const storeCallbackParams = ps ? ', ' + ps.map(p => `storeFn_${p}: StoreCallback<${p}>`).join(', ') : '';
     ctx.has_customPackUnpack || (ctx.has_customPackUnpack = a.custom_pack_unpack !== undefined);
-    buf.push(renderAliasDocComment(a));
-    if (a.target_ty.kind === 'union') {
+    buf.push(renderAliasDocComment(ctx, a));
+    const targetTy = ctx.symbols.tyByIdx(a.target_ty_idx);
+    if (targetTy.kind === 'union') {
         buf.push(`export type ${aliasName}${genericTs} =`).indent();
-        for (const v of (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, a.target_ty.variants)) {
-            buf.push('| ' + (0, emit_ts_types_1.emitUnionLabelAndValue)(v, (0, emit_ts_types_1.emitTsType)(ctx, v.variant_ty)));
+        for (const v of (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, targetTy.variants)) {
+            buf.push('| ' + (0, emit_ts_types_1.emitUnionLabelAndValue)(v, (0, emit_ts_types_1.emitTsType)(ctx, v.variant_ty_idx)));
         }
         buf.outdent();
     }
     else {
-        buf.push(`export type ${aliasName}${genericTs} = ${(0, emit_ts_types_1.emitTsType)(ctx, a.target_ty)}`);
+        buf.push(`export type ${aliasName}${genericTs} = ${(0, emit_ts_types_1.emitTsType)(ctx, a.target_ty_idx)}`);
+    }
+    if (ps) { // generic aliases don't have `fromSlice` and `store`
+        return buf.toString();
     }
     buf.emptyLine();
     buf.push(`export const ${aliasName} = {`);
-    buf.push(`fromSlice${genericTs}(s: c.Slice${loadCallbackParams}): ${aliasName}${genericTs} {`);
-    if (a.custom_pack_unpack?.unpack_from_slice) {
-        buf.push(`return invokeCustomUnpackFromSlice<${aliasName}>('${a.name}', s);`);
+    buf.push(`fromSlice(s: c.Slice): ${aliasName} {`);
+    try {
+        buf.push((0, emit_pack_unpack_1.emitLoadOfAlias)(ctx, a, a.ty_idx));
+    }
+    catch (ex) {
+        buf.push(renderThrowCantPackUnpack(aliasName, ex, false));
     }
-    else
-        try {
-            buf.push(`return ${(0, emit_pack_unpack_1.emitLoadExpr)(ctx, aliasName, a.target_ty)};`);
-        }
-        catch (ex) {
-            buf.push(renderThrowCantPackUnpack(aliasName, ex, false));
-        }
     buf.push(`},`);
-    buf.push(`store${genericTs}(self: ${aliasName}${genericTs}, b: c.Builder${storeCallbackParams}): void {`);
-    if (a.custom_pack_unpack?.pack_to_builder) {
-        buf.push(`invokeCustomPackToBuilder<${aliasName}>('${a.name}', self, b);`);
+    buf.push(`store(self: ${aliasName}, b: c.Builder): void {`);
+    try {
+        buf.push((0, emit_pack_unpack_1.emitStoreOfAlias)(ctx, 'self', a, a.ty_idx));
+    }
+    catch (ex) {
+        buf.push(renderThrowCantPackUnpack(aliasName, ex, true));
     }
-    else
-        try {
-            buf.push((0, emit_pack_unpack_1.emitStoreStatement)(ctx, 'self', a.target_ty));
-        }
-        catch (ex) {
-            buf.push(renderThrowCantPackUnpack(aliasName, ex, true));
-        }
     buf.push(`},`);
-    buf.push(`toCell${genericTs}(self: ${aliasName}${genericTs}${storeCallbackParams}): c.Cell {`);
-    buf.push(`return ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, 'self', aliasTy, true)};`);
+    buf.push(`toCell(self: ${aliasName}): c.Cell {`);
+    buf.push(`return ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, 'self', a.ty_idx, true)};`);
     buf.push('}');
     buf.push('}');
     return buf.toString();
@@ -185,7 +156,6 @@ function tolkAliasToTypeScript(ctx, a, buf) {
 // Tolk `enum X` -> TS `type X = bigint` + `const X` with members and serializers.
 function tolkEnumToTypeScript(ctx, e, buf) {
     const enumName = (0, formatting_1.safeJsIdent)(e.name);
-    const enumTy = { kind: 'EnumRef', enum_name: e.name };
     buf.push(renderEnumDocComment(e));
     buf.push(`export type ${enumName} = bigint`);
     buf.emptyLine();
@@ -199,23 +169,13 @@ function tolkEnumToTypeScript(ctx, e, buf) {
     }
     buf.emptyLine();
     buf.push(`fromSlice(s: c.Slice): ${enumName} {`);
-    if (e.custom_pack_unpack?.unpack_from_slice) {
-        buf.push(`return invokeCustomUnpackFromSlice<${enumName}>('${e.name}', s);`);
-    }
-    else {
-        buf.push(`return ${(0, emit_pack_unpack_1.emitLoadExpr)(ctx, e.name, e.encoded_as)};`);
-    }
+    buf.push((0, emit_pack_unpack_1.emitLoadOfEnum)(ctx, e));
     buf.push(`},`);
     buf.push(`store(self: ${enumName}, b: c.Builder): void {`);
-    if (e.custom_pack_unpack?.pack_to_builder) {
-        buf.push(`return invokeCustomPackToBuilder<${enumName}>('${e.name}', self, b);`);
-    }
-    else {
-        buf.push((0, emit_pack_unpack_1.emitStoreStatement)(ctx, 'self', e.encoded_as));
-    }
+    buf.push((0, emit_pack_unpack_1.emitStoreOfEnum)(ctx, 'self', e));
     buf.push(`},`);
     buf.push(`toCell(self: ${enumName}): c.Cell {`);
-    buf.push(`return ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, 'self', enumTy, true)};`);
+    buf.push(`return ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, 'self', e.ty_idx, true)};`);
     buf.push('}');
     buf.push('}');
     return buf.toString();
@@ -228,35 +188,34 @@ function snakeCaseToCamelCase(snakeString) {
 // so that on a caller side, one can use `contract.sendXXX({ queryId: 0n, ... })`
 // instead of `contract.sendXXX(XXX.create({ queryId: 0n, ... }))` (although the latter is also acceptable).
 // Note that if a field has a default value, it's declared as optional (`f?: T`, not `f: T`).
-function structParameterNoLabel(ctx, structName, typeArgs) {
-    const structRef = ctx.symbols.getStruct(structName);
+function structParameterNoLabel(ctx, structTyIdx) {
     let declBuf = new formatting_1.OutBuf();
     declBuf.push(`{`);
-    for (let f of structRef.fields) {
-        let comment = f.default_value ? ` /* = ${(0, emit_field_defs_1.emitFieldDefaultInComment)(f.default_value)} */` : '';
-        let fTy = typeArgs ? (0, types_kernel_1.instantiateGenerics)(f.ty, structRef.type_params, typeArgs) : f.ty;
-        declBuf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}${f.default_value && (0, emit_field_defs_1.isDefaultValueSupported)(fTy) ? '?' : ''}: ${(0, emit_ts_types_1.emitTsType)(ctx, fTy)}${comment}`);
+    for (let f of ctx.symbols.structFieldsOf(structTyIdx)) {
+        let comment = f.default_value ? ` /* = ${(0, emit_field_defs_1.emitFieldDefaultInComment)(ctx, f.default_value)} */` : '';
+        declBuf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}${f.default_value && (0, emit_field_defs_1.isDefaultValueSupported)(ctx, f.ty_idx) ? '?' : ''}: ${(0, emit_ts_types_1.emitTsType)(ctx, f.ty_idx)}${comment}`);
     }
     declBuf.push(`}`);
     return declBuf.toString();
 }
 // Generate `static fromStorage()` method for a storage of type {ty}.
 // Most likely, it's a struct, then a caller can just use `MyContract.fromStorage({ fields })`.
-function generateFromStorageMethod(ctx, ty, contractName) {
-    if (ty == null || ty.kind === 'nullLiteral') { // means "no storage, don't emit a method"
+function generateFromStorageMethod(ctx, tyIdx, contractName) {
+    if (tyIdx == null || ctx.symbols.tyByIdx(tyIdx).kind === 'nullLiteral') { // means "no storage, don't emit a method"
         return '';
     }
-    let storageParamT = (0, emit_ts_types_1.emitTsType)(ctx, ty);
+    const ty = ctx.symbols.tyByIdx(tyIdx);
+    let storageParamT = (0, emit_ts_types_1.emitTsType)(ctx, tyIdx);
     let bodyArg = 'emptyStorage';
     if (ty.kind === 'StructRef') {
-        storageParamT = structParameterNoLabel(ctx, ty.struct_name, ty.type_args);
-        bodyArg = (0, emit_pack_unpack_1.emitCallToCreateMethodExpr)(ctx, 'emptyStorage', ty);
+        storageParamT = structParameterNoLabel(ctx, tyIdx);
+        bodyArg = (0, emit_pack_unpack_1.emitCallToCreateMethodExpr)(ctx, 'emptyStorage', tyIdx);
     }
     let buf = new formatting_1.OutBuf();
     buf.push(`static fromStorage(emptyStorage: ${storageParamT}, deployedOptions?: DeployedAddrOptions) {`);
     buf.push(`const initialState = {`);
     buf.push(`code: deployedOptions?.overrideContractCode ?? ${contractName}.CodeCell,`);
-    buf.push(`data: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, bodyArg, ty)},`);
+    buf.push(`data: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, bodyArg, tyIdx)},`);
     buf.push(`};`);
     buf.push(`const address = calculateDeployedAddress(initialState.code, initialState.data, deployedOptions ?? {});`);
     buf.push(`return new ${contractName}(address, initialState);`);
@@ -266,35 +225,37 @@ function generateFromStorageMethod(ctx, ty, contractName) {
 // Generate a `createCellOfXXX` static method for a contract class.
 // It's essentially a wrapper for `XXX.toCell(XXX.create(body))`, but quite handy for the end user,
 // to make a cell for TON Connect. In practice, `toCell` is needed almost for messages only.
-function generateCreateCellOfMessageMethod(ctx, ty) {
-    let functionName = snakeCaseToCamelCase((0, formatting_1.safeJsIdent)(`createCellOf_${(0, types_kernel_1.renderTy)(ty)}`));
-    let bodyParamT = (0, emit_ts_types_1.emitTsType)(ctx, ty);
+function generateCreateCellOfMessageMethod(ctx, tyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
+    let functionName = snakeCaseToCamelCase((0, formatting_1.safeJsIdent)(`createCellOf_${(0, types_kernel_1.renderTy)(ctx.symbols, tyIdx)}`));
+    let bodyParamT = (0, emit_ts_types_1.emitTsType)(ctx, tyIdx);
     let bodyArg = 'body';
     if (ty.kind === 'StructRef') {
-        bodyParamT = structParameterNoLabel(ctx, ty.struct_name, ty.type_args);
-        bodyArg = (0, emit_pack_unpack_1.emitCallToCreateMethodExpr)(ctx, 'body', ty);
+        bodyParamT = structParameterNoLabel(ctx, tyIdx);
+        bodyArg = (0, emit_pack_unpack_1.emitCallToCreateMethodExpr)(ctx, 'body', tyIdx);
     }
     let buf = new formatting_1.OutBuf();
     buf.push(`static ${functionName}(body: ${bodyParamT}) {`);
-    buf.push(`return ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, bodyArg, ty)};`);
+    buf.push(`return ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, bodyArg, tyIdx)};`);
     buf.push(`}`);
     return buf.toString();
 }
 // Generate a `sendXXX` method for a message of type {ty}.
 // Most likely, it's a struct (an instantiated one also possible), but it can also be an alias for example.
-function generateSendMethod(ctx, ty) {
-    let functionName = snakeCaseToCamelCase((0, formatting_1.safeJsIdent)(`send_${(0, types_kernel_1.renderTy)(ty)}`));
-    let bodyParamT = (0, emit_ts_types_1.emitTsType)(ctx, ty);
+function generateSendMethod(ctx, tyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
+    let functionName = snakeCaseToCamelCase((0, formatting_1.safeJsIdent)(`send_${(0, types_kernel_1.renderTy)(ctx.symbols, tyIdx)}`));
+    let bodyParamT = (0, emit_ts_types_1.emitTsType)(ctx, tyIdx);
     let bodyArg = 'body';
     if (ty.kind === 'StructRef') {
-        bodyParamT = structParameterNoLabel(ctx, ty.struct_name, ty.type_args);
-        bodyArg = (0, emit_pack_unpack_1.emitCallToCreateMethodExpr)(ctx, 'body', ty);
+        bodyParamT = structParameterNoLabel(ctx, tyIdx);
+        bodyArg = (0, emit_pack_unpack_1.emitCallToCreateMethodExpr)(ctx, 'body', tyIdx);
     }
     let buf = new formatting_1.OutBuf();
     buf.push(`async ${functionName}(provider: ContractProvider, via: Sender, msgValue: coins, body: ${bodyParamT}, extraOptions?: ${codegen_ctx_1.RUNTIME.ExtraSendOptions}) {`);
     buf.push(`return provider.internal(via, {`);
     buf.push(`value: msgValue,`);
-    buf.push(`body: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, bodyArg, ty)},`);
+    buf.push(`body: ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, bodyArg, tyIdx)},`);
     buf.push(`...extraOptions`);
     buf.push(`});`);
     buf.push(`}`);
@@ -313,21 +274,22 @@ function generateGetMethod(ctx, getM) {
         return (0, formatting_1.safeJsIdent)(collision ? p.name + '_' : p.name);
     });
     let buf = new formatting_1.OutBuf();
-    let paramsStr = nParams ? `, ${getM.parameters.map((p, i) => `${paramNames[i]}: ${(0, emit_ts_types_1.emitTsType)(ctx, p.ty)}${p.default_value ? ` = ${(0, emit_field_defs_1.emitFieldDefault)(ctx, p.default_value)}` : ''}`).join(', ')}` : '';
-    if (getM.return_ty.kind === 'tensor') {
+    let paramsStr = nParams ? `, ${getM.parameters.map((p, i) => `${paramNames[i]}: ${(0, emit_ts_types_1.emitTsType)(ctx, p.ty_idx)}${p.default_value ? ` = ${(0, emit_field_defs_1.emitFieldDefault)(ctx, p.default_value)}` : ''}`).join(', ')}` : '';
+    const returnTy = ctx.symbols.tyByIdx(getM.return_ty_idx);
+    if (returnTy.kind === 'tensor') {
         buf.push(`async ${functionName}(provider: ContractProvider${paramsStr}): Promise<[`);
-        for (let item of getM.return_ty.items) {
+        for (let item of returnTy.items_ty_idx) {
             buf.push((0, emit_ts_types_1.emitTsType)(ctx, item) + ',');
         }
         buf.push(']> {');
     }
     else {
-        buf.push(`async ${functionName}(provider: ContractProvider${paramsStr}): Promise<${(0, emit_ts_types_1.emitTsType)(ctx, getM.return_ty)}> {`);
+        buf.push(`async ${functionName}(provider: ContractProvider${paramsStr}): Promise<${(0, emit_ts_types_1.emitTsType)(ctx, getM.return_ty_idx)}> {`);
     }
-    let stackW = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, getM.return_ty);
+    let stackW = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, getM.return_ty_idx);
     if (nParams) {
         buf.push(`const r = ${codegen_ctx_1.RUNTIME.StackReader}.fromGetMethod(${stackW}, await provider.get('${getM.name}', [`);
-        let stackWrites = getM.parameters.flatMap((p, i) => (0, emit_stack_rw_1.emitStackWriteItems)(ctx, paramNames[i], p.ty));
+        let stackWrites = getM.parameters.flatMap((p, i) => (0, emit_stack_rw_1.emitStackWriteItems)(ctx, paramNames[i], p.ty_idx));
         for (let w of stackWrites) {
             buf.push(w + ',');
         }
@@ -336,7 +298,7 @@ function generateGetMethod(ctx, getM) {
     else {
         buf.push(`const r = ${codegen_ctx_1.RUNTIME.StackReader}.fromGetMethod(${stackW}, await provider.get('${getM.name}', []));`);
     }
-    buf.push(`return ${(0, emit_stack_rw_1.emitStackReadExpr)(ctx, 'result', getM.return_ty)};`);
+    buf.push(`return ${(0, emit_stack_rw_1.emitStackReadExpr)(ctx, 'result', getM.return_ty_idx)};`);
     buf.push(`}`);
     return buf.toString();
 }
@@ -360,10 +322,10 @@ function renderTsTemplate(tplStr, content) {
  * and returns the full TypeScript wrapper with all serializers, send, and get methods.
  * @throws CantGenerateWrappersAtAll
  */
-function generateTypeScriptFileForContract(contract) {
-    let ctx = new codegen_ctx_1.CodegenCtx(contract.declarations);
+function generateTypeScriptFileForContract(abi) {
+    let ctx = new codegen_ctx_1.CodegenCtx(abi);
     const declarationsBuf = new formatting_1.OutBuf();
-    for (const n of contract.declarations) {
+    for (const n of abi.declarations) {
         try {
             if (n.kind === 'struct')
                 tolkStructToTypeScript(ctx, n, declarationsBuf);
@@ -378,16 +340,16 @@ function generateTypeScriptFileForContract(contract) {
         }
     }
     let packUnpackSerializers = declarationsBuf.toString();
-    let createCellsMethodsStr = contract.incoming_messages.map(msg => generateCreateCellOfMessageMethod(ctx, msg.body_ty));
-    let sendMethodsStr = contract.incoming_messages.map(msg => {
+    let createCellsMethodsStr = abi.incoming_messages.map(msg => generateCreateCellOfMessageMethod(ctx, msg.body_ty_idx));
+    let sendMethodsStr = abi.incoming_messages.map(msg => {
         try {
-            return generateSendMethod(ctx, msg.body_ty);
+            return generateSendMethod(ctx, msg.body_ty_idx);
         }
         catch (ex) {
-            throw new unsupported_errors_1.CantGenerateWrappersAtAll(`Error while generating send method '${(0, types_kernel_1.renderTy)(msg.body_ty)}'`, ex);
+            throw new unsupported_errors_1.CantGenerateWrappersAtAll(`Error while generating send method '${(0, types_kernel_1.renderTy)(ctx.symbols, msg.body_ty_idx)}'`, ex);
         }
     });
-    let getMethodsStr = contract.get_methods.map(getM => {
+    let getMethodsStr = abi.get_methods.filter(getM => getM.tvm_method_id !== 0).map(getM => {
         try {
             return generateGetMethod(ctx, getM);
         }
@@ -399,9 +361,9 @@ function generateTypeScriptFileForContract(contract) {
     let uintNAliasesStr = ctx.sortOccurred(ctx.uintNOccurred).map(uintN => `type ${uintN} = bigint`);
     let varIntNAliasesStr = ctx.sortOccurred(ctx.varIntNOccurred).map(varIntN => `type ${varIntN} = bigint`);
     let sliceAliasesStr = ctx.sortOccurred(ctx.bitsNOccurred).map(bitsN => `type ${bitsN} = c.Slice`);
-    let errorCodesStr = contract.thrown_errors.filter(t => t.name).map(t => `'${t.name}': ${t.err_code},`);
+    let errorCodesStr = abi.thrown_errors.filter(t => t.name).map(t => `'${t.name}': ${t.err_code},`);
     return renderTsTemplate(out_template_generated_1.OUT_TEMPLATE, {
-        contractClassName: contract.contract_name,
+        contractClassName: abi.contract_name,
         flags: {
             'has_sendDeploy': true,
             'has_bitsN': ctx.bitsNOccurred.size > 0,
@@ -433,9 +395,9 @@ function generateTypeScriptFileForContract(contract) {
             'varIntNAliases': varIntNAliasesStr.join('\n'),
             'sliceAliases': sliceAliasesStr.join('\n'),
             'packUnpackSerializers': packUnpackSerializers,
-            'codeBoc64': contract.codeBoc64,
+            'codeBoc64': abi.code_boc64,
             'errorCodes': errorCodesStr.join('\n'),
-            'fromStorageMethod': generateFromStorageMethod(ctx, contract.storage.storage_at_deployment_ty ?? contract.storage.storage_ty, contract.contract_name),
+            'fromStorageMethod': generateFromStorageMethod(ctx, abi.storage.storage_at_deployment_ty_idx ?? abi.storage.storage_ty_idx, abi.contract_name),
             'createCellsMethods': createCellsMethodsStr.join('\n\n'),
             'sendMethods': sendMethodsStr.join('\n\n'),
             'getMethods': getMethodsStr.join('\n\n'),

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 export { generateTypeScriptFileForContract } from './generate-ts-wrappers';
 export { DynamicCtx } from './dynamic-ctx';
 export { debugPrintFromStack } from './dynamic-debug-print';
-export { callGetMethodDynamic, makeTvmTupleDynamic, StackReader, } from './dynamic-get-methods';
-export { createTonCoreDictionaryKey, createTonCoreDictionaryValue, dynamicPack, dynamicUnpack, packToBuilderDynamic, unpackFromSliceDynamic, } from './dynamic-serialization';
-export type { ContractABI, ABIGetMethod } from './abi';
-export type { ABIConstExpression, ABIAlias, ABIEnum, ABIStruct, Ty, } from './abi-types';
+export { callGetMethodDynamic, makeTvmTupleDynamic } from './dynamic-get-methods';
+export { packToBuilderDynamic, unpackFromSliceDynamic } from './dynamic-serialization';
+export { renderTy, SymTable } from './types-kernel';
+export type { ABIExternalMessage, ABIGetMethod, ABIInternalMessage, ABIOutgoingMessage, ABIStorage, ABIThrownError, ContractABI, } from './abi';
+export type { ABIConstExpression, ABICustomSerializers, ABIAlias, ABIEnum, ABIStruct, Ty, UnionVariant, } from './abi-types';
 export { CantGeneratePackUnpack, CantGenerateWrappersAtAll, CantCallGetMethodDynamic, CantPackDynamic, CantUnpackDynamic, InvalidDynamicInput, NonStandardDictKey, NotSupportedTypeOnStack, SymbolNotFound, } from './unsupported-errors';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SymbolNotFound = exports.NotSupportedTypeOnStack = exports.NonStandardDictKey = exports.InvalidDynamicInput = exports.CantUnpackDynamic = exports.CantPackDynamic = exports.CantCallGetMethodDynamic = exports.CantGenerateWrappersAtAll = exports.CantGeneratePackUnpack = exports.unpackFromSliceDynamic = exports.packToBuilderDynamic = exports.dynamicUnpack = exports.dynamicPack = exports.createTonCoreDictionaryValue = exports.createTonCoreDictionaryKey = exports.StackReader = exports.makeTvmTupleDynamic = exports.callGetMethodDynamic = exports.debugPrintFromStack = exports.DynamicCtx = exports.generateTypeScriptFileForContract = void 0;
+exports.SymbolNotFound = exports.NotSupportedTypeOnStack = exports.NonStandardDictKey = exports.InvalidDynamicInput = exports.CantUnpackDynamic = exports.CantPackDynamic = exports.CantCallGetMethodDynamic = exports.CantGenerateWrappersAtAll = exports.CantGeneratePackUnpack = exports.SymTable = exports.renderTy = exports.unpackFromSliceDynamic = exports.packToBuilderDynamic = exports.makeTvmTupleDynamic = exports.callGetMethodDynamic = exports.debugPrintFromStack = exports.DynamicCtx = exports.generateTypeScriptFileForContract = void 0;
 var generate_ts_wrappers_1 = require("./generate-ts-wrappers");
 Object.defineProperty(exports, "generateTypeScriptFileForContract", { enumerable: true, get: function () { return generate_ts_wrappers_1.generateTypeScriptFileForContract; } });
 var dynamic_ctx_1 = require("./dynamic-ctx");
@@ -10,14 +10,12 @@ Object.defineProperty(exports, "debugPrintFromStack", { enumerable: true, get: f
 var dynamic_get_methods_1 = require("./dynamic-get-methods");
 Object.defineProperty(exports, "callGetMethodDynamic", { enumerable: true, get: function () { return dynamic_get_methods_1.callGetMethodDynamic; } });
 Object.defineProperty(exports, "makeTvmTupleDynamic", { enumerable: true, get: function () { return dynamic_get_methods_1.makeTvmTupleDynamic; } });
-Object.defineProperty(exports, "StackReader", { enumerable: true, get: function () { return dynamic_get_methods_1.StackReader; } });
 var dynamic_serialization_1 = require("./dynamic-serialization");
-Object.defineProperty(exports, "createTonCoreDictionaryKey", { enumerable: true, get: function () { return dynamic_serialization_1.createTonCoreDictionaryKey; } });
-Object.defineProperty(exports, "createTonCoreDictionaryValue", { enumerable: true, get: function () { return dynamic_serialization_1.createTonCoreDictionaryValue; } });
-Object.defineProperty(exports, "dynamicPack", { enumerable: true, get: function () { return dynamic_serialization_1.dynamicPack; } });
-Object.defineProperty(exports, "dynamicUnpack", { enumerable: true, get: function () { return dynamic_serialization_1.dynamicUnpack; } });
 Object.defineProperty(exports, "packToBuilderDynamic", { enumerable: true, get: function () { return dynamic_serialization_1.packToBuilderDynamic; } });
 Object.defineProperty(exports, "unpackFromSliceDynamic", { enumerable: true, get: function () { return dynamic_serialization_1.unpackFromSliceDynamic; } });
+var types_kernel_1 = require("./types-kernel");
+Object.defineProperty(exports, "renderTy", { enumerable: true, get: function () { return types_kernel_1.renderTy; } });
+Object.defineProperty(exports, "SymTable", { enumerable: true, get: function () { return types_kernel_1.SymTable; } });
 var unsupported_errors_1 = require("./unsupported-errors");
 Object.defineProperty(exports, "CantGeneratePackUnpack", { enumerable: true, get: function () { return unsupported_errors_1.CantGeneratePackUnpack; } });
 Object.defineProperty(exports, "CantGenerateWrappersAtAll", { enumerable: true, get: function () { return unsupported_errors_1.CantGenerateWrappersAtAll; } });

package/dist/types-kernel.d.ts

@@ -1,10 +1,28 @@
-import type { Ty, UnionVariant } from './abi-types';
-import { SymTable } from './codegen-ctx';
-export declare function renderTy(ty: Ty): string;
+import type { ABIAlias, ABIAliasInstantiation, ABIEnum, ABIStruct, ABIStructInstantiation, Ty, UnionVariant } from './abi-types';
+export declare class SymTable {
+    private readonly structs;
+    private readonly aliases;
+    private readonly enums;
+    private readonly uniqueTypes;
+    private readonly structInstantiations;
+    private readonly aliasInstantiations;
+    constructor(declarations: (ABIStruct | ABIAlias | ABIEnum)[], uniqueTypes: Ty[], structInstantiations: ABIStructInstantiation[], aliasInstantiations: ABIAliasInstantiation[]);
+    getStruct(structName: string): ABIStruct;
+    getAlias(aliasName: string): ABIAlias;
+    getEnum(enumName: string): ABIEnum;
+    tyByIdx(tyIdx: number): Ty;
+    structFieldsOf(tyIdx: number): (ABIStruct['fields'][number] & {
+        uLabelTyIdx?: number;
+    })[];
+    aliasTargetOf(tyIdx: number): {
+        ty_idx: number;
+        uLabelTyIdx?: number;
+    };
+}
+export declare function renderTy(symbols: SymTable, tyIdx: number): string;
 export interface UnionVariantLabeled extends UnionVariant {
     labelStr: string;
     hasValueField: boolean;
 }
-export declare function createLabelsForUnion(symbols: SymTable, variants: UnionVariant[]): UnionVariantLabeled[];
-export declare function instantiateGenerics(ty: Ty, typeParams: string[] | undefined, typeArgs: Ty[]): Ty;
-export declare function calcWidthOnStack(symbols: SymTable, ty: Ty): number;
+export declare function createLabelsForUnion(symbols: SymTable, variants: UnionVariant[], uLabelTyIdx?: number): UnionVariantLabeled[];
+export declare function calcWidthOnStack(symbols: SymTable, tyIdx: number): number;