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

package/{src/formatting.ts → dist/formatting.js}

@@ -1,48 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutBuf = void 0;
+exports.safeJsIdent = safeJsIdent;
+exports.safeFieldDecl = safeFieldDecl;
+exports.safeFieldRead = safeFieldRead;
 // OutBuf helps to generate TypeScript output with proper indentation.
-export class OutBuf {
-    static TAB = '    '
-
-    static onNewLine(s: string): string {
+class OutBuf {
+    constructor() {
+        this.lines = [];
+        this.indentLevel = 0;
+    }
+    static onNewLine(s) {
         return `{indent}${s}{outdent}`;
     }
-
-    private static indentNested(input: string, indentLevel: number): string {
+    static indentNested(input, indentLevel) {
         let result = '';
         let i = 0;
-
         while (i < input.length) {
             if (input.startsWith('{indent}', i)) {
                 result += '\n' + '    '.repeat(++indentLevel);
                 i += 8;
-            } else if (input.startsWith('{outdent}', i)) {
+            }
+            else if (input.startsWith('{outdent}', i)) {
                 result += '\n' + '    '.repeat(--indentLevel);
                 i += 9;
-            } else if (input[i] === '\n') {
+            }
+            else if (input[i] === '\n') {
                 result += '\n' + '    '.repeat(indentLevel);
                 i++;
-            } else {
+            }
+            else {
                 result += input[i];
                 i++;
             }
         }
-
         return result;
     }
-
-    private lines = [] as string[];
-    private indentLevel = 0;
-
     indent() { this.indentLevel++; }
     outdent() { this.indentLevel--; }
     emptyLine() { this.lines.push(''); }
-
-    push(line: string) {
+    push(line) {
         if (line.includes('{indent}') || line.includes('\n')) {
             line = OutBuf.indentNested(line.trimEnd(), this.indentLevel);
             line = line.replace(/\s+\n/g, '\n');
             line = line.replace(/\n\s+,/g, ',');
         }
-
         if (line.startsWith('}') || line.startsWith(']') || line.startsWith(')')) {
             this.outdent();
         }
@@ -52,47 +54,43 @@ export class OutBuf {
         }
         return this;
     }
-
     toString() {
         return this.lines.join('\n');
     }
 }
-
+exports.OutBuf = OutBuf;
+OutBuf.TAB = '    ';
 // In Tolk, similar to Kotlin, identifiers (structs, fields, etc.) can be embraced:
 // > struct `foo-bar` { `a()`: int }
 // Such names are incorrect in TS/JS and require special handling.
-function isSafeJsIdent(tolkStructName: string): boolean {
+function isSafeJsIdent(tolkStructName) {
     return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(tolkStructName);
 }
-
 // In TS, `interface` and `const` can not contain '-' and other invalid symbols,
 // so we mangle them: "foo-bar@" -> "foo_bar_".
 // NB! Keywords, like 'await' or 'function', are also invalid identifiers,
 // but since structs and type aliases are recommended to be named CamelCase in Tolk contracts,
 // we don't expect collisions with JS keywords here.
-export function safeJsIdent(tolkIdentifier: string): string {
+function safeJsIdent(tolkIdentifier) {
     if (isSafeJsIdent(tolkIdentifier)) {
         return tolkIdentifier;
     }
-
     let safe = tolkIdentifier.replace(/[^a-zA-Z0-9_$]/g, '_');
     if (/^[0-9]/.test(safe)) {
         safe = '_' + safe;
     }
     return safe;
 }
-
 // In object literals, 'foo-bar' can be used (without mangling to '_') if quoted:
 // > interface A { foo: number, "foo-bar": number }
 // > return { foo: 0, "foo-bar": 123 }
 // Also, `__proto__` requires special handling, but I decided not to take it into account.
-export function safeFieldDecl(fieldName: string): string {
+function safeFieldDecl(fieldName) {
     return isSafeJsIdent(fieldName) ? fieldName : JSON.stringify(fieldName);
 }
-
 // When accessing object fields, use ["syntax"] for invalid identifiers:
 // > obj.foo
 // > obj["foo-bar"]
-export function safeFieldRead(fieldName: string): string {
+function safeFieldRead(fieldName) {
     return isSafeJsIdent(fieldName) ? `.${fieldName}` : `[${JSON.stringify(fieldName)}]`;
 }

package/dist/generate-ts-wrappers.d.ts

@@ -0,0 +1,7 @@
+import type { ContractABI } from './abi';
+/**
+ * The main function: accepts top-level declarations from Tolk sources (converted to ABI)
+ * and returns the full TypeScript wrapper with all serializers, send, and get methods.
+ * @throws CantGenerateWrappersAtAll
+ */
+export declare function generateTypeScriptFileForContract(contract: ContractABI): string;

package/dist/generate-ts-wrappers.js

@@ -0,0 +1,444 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypeScriptFileForContract = generateTypeScriptFileForContract;
+const codegen_ctx_1 = require("./codegen-ctx");
+const formatting_1 = require("./formatting");
+const emit_ts_types_1 = require("./emit-ts-types");
+const emit_pack_unpack_1 = require("./emit-pack-unpack");
+const emit_stack_rw_1 = require("./emit-stack-rw");
+const emit_field_defs_1 = require("./emit-field-defs");
+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) {
+    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)}`),
+        ' > }',
+        ' */'
+    ].join('\n');
+}
+// Output an alias as a doc comment.
+function renderAliasDocComment(a) {
+    const genericTs = a.type_params ? `<${a.type_params.join(', ')}>` : '';
+    return [
+        '/**',
+        ` > type ${a.name}${genericTs} = ${(0, types_kernel_1.renderTy)(a.target_ty)}`,
+        ' */'
+    ].join('\n');
+}
+// Output an enum as a doc comment.
+function renderEnumDocComment(e) {
+    return [
+        '/**',
+        ` > enum ${e.name} { ${e.members.length} variants }`,
+        ' */'
+    ].join('\n');
+}
+// If a struct can't be serialized, then its `fromSlice`/`store` is just `throw` with description.
+// Since Tolk code contains many structs (some are used for contract getters, for example),
+// not all of them are intended for serialization, it's expected.
+function renderThrowCantPackUnpack(structName, caughtEx, isPack) {
+    if (!(caughtEx instanceof unsupported_errors_1.CantGeneratePackUnpack))
+        throw caughtEx;
+    const action = isPack ? `pack '${structName}' to cell` : `unpack '${structName}' from cell`;
+    return `throw new Error(\`Can't ${action}, because ${caughtEx.message}\`);`;
+}
+// All-in-one: a struct with autogen serializers.
+// Tolk `struct X` -> TS `interface X` { $: 'X'; ...fields } + `const X` with serializers.
+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(`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}`);
+    }
+    buf.push('}');
+    buf.emptyLine();
+    buf.push(`export const ${structName} = {`);
+    if (s.prefix) {
+        buf.push(`PREFIX: ${s.prefix.prefix_str},`);
+        buf.emptyLine();
+    }
+    let argsParam = s.fields.length ? 'args: ' + structParameterNoLabel(ctx, s.name) : '';
+    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';
+        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) {
+        buf.push('...args');
+    }
+    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);`);
+    }
+    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);`);
+    }
+    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('}');
+    buf.push('}');
+    return buf.toString();
+}
+// All-in-one: an alias with autogen serializers.
+// Tolk `type X = Y` -> TS `type X = Y` (interchangeable with its underlying type, like in Tolk).
+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(`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)));
+        }
+        buf.outdent();
+    }
+    else {
+        buf.push(`export type ${aliasName}${genericTs} = ${(0, emit_ts_types_1.emitTsType)(ctx, a.target_ty)}`);
+    }
+    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);`);
+    }
+    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);`);
+    }
+    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('}');
+    buf.push('}');
+    return buf.toString();
+}
+// All-in-one: an enum with autogen serializers.
+// 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();
+    buf.push(`export const ${enumName} = {`);
+    for (const v of e.members) {
+        let memberName = v.name;
+        if (memberName === 'toCell' || memberName === 'store' || memberName === 'fromSlice') {
+            memberName += '_';
+        }
+        buf.push(`${(0, formatting_1.safeFieldDecl)(memberName)}: ${v.value}n,`);
+    }
+    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(`},`);
+    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(`},`);
+    buf.push(`toCell(self: ${enumName}): c.Cell {`);
+    buf.push(`return ${(0, emit_pack_unpack_1.emitMakeCellFromExpr)(ctx, 'self', enumTy, true)};`);
+    buf.push('}');
+    buf.push('}');
+    return buf.toString();
+}
+// Convert "get_wallet_data" to "getWalletData".
+function snakeCaseToCamelCase(snakeString) {
+    return snakeString.replace(/_([a-zA-Z])/g, (_, letter) => letter.toUpperCase());
+}
+// For sendXXX contract methods, we generate not `(msg: XXX)` but `(body: { ...fields })`,
+// 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);
+    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}`);
+    }
+    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"
+        return '';
+    }
+    let storageParamT = (0, emit_ts_types_1.emitTsType)(ctx, ty);
+    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);
+    }
+    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(`};`);
+    buf.push(`const address = calculateDeployedAddress(initialState.code, initialState.data, deployedOptions ?? {});`);
+    buf.push(`return new ${contractName}(address, initialState);`);
+    buf.push(`}`);
+    return buf.toString();
+}
+// 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);
+    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);
+    }
+    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 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);
+    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);
+    }
+    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(`...extraOptions`);
+    buf.push(`});`);
+    buf.push(`}`);
+    return buf.toString();
+}
+// Generate a `getXXX` method: a contract getter that works off-chain, via the stack.
+function generateGetMethod(ctx, getM) {
+    let functionName = snakeCaseToCamelCase((0, formatting_1.safeJsIdent)('get_' + getM.name));
+    functionName = functionName.replace(/^getGet/, 'get');
+    let nParams = getM.parameters.length;
+    let paramNames = getM.parameters.map(p => {
+        let collision = Object.values(codegen_ctx_1.RUNTIME).some(n => p.name === n)
+            || p.name === 'c' // import @ton/core
+            || p.name === 'r' // StackReader in body
+            || p.name === 'provider'; // implicit parameter
+        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') {
+        buf.push(`async ${functionName}(provider: ContractProvider${paramsStr}): Promise<[`);
+        for (let item of getM.return_ty.items) {
+            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)}> {`);
+    }
+    let stackW = (0, types_kernel_1.calcWidthOnStack)(ctx.symbols, getM.return_ty);
+    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));
+        for (let w of stackWrites) {
+            buf.push(w + ',');
+        }
+        buf.push(`]));`);
+    }
+    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 buf.toString();
+}
+// Render a template of a TypeScript wrapper.
+function renderTsTemplate(tplStr, content) {
+    // {{if:...}} blocks: keep blank lines before it if true
+    const IF_BLOCK_RE = /(^(?:\s*\n)*)\s*\/\/\s*{{if:(\w+)}}[^\n]*\n([\s\S]+?)^\s*\/\/\s*{{\/if:\2}}[^\n]*/gm;
+    tplStr = tplStr.replace(IF_BLOCK_RE, (_m, leadingBlank, name, inner) => content.flags[name] ? leadingBlank + inner : '');
+    // {{slot}}: keep indentation, remove a commented marker
+    const SLOT_RE = /(^ *)(?:\/\/\s*)?{{(\w+)}}[^\n]*$/gm;
+    tplStr = tplStr.replace(SLOT_RE, (_m, indent, name) => content.slots[name].split('\n').map(l => l.length ? indent + l : '').join('\n'));
+    // {{slot}} inlined (without a preceding comment)
+    tplStr = tplStr.replace(/{{(\w+)}}/g, (_m, name) => content.slots[name]);
+    return tplStr
+        .replace(/\n\s*\n(\s*})/g, '\n$1') // remove an empty line before closing brace
+        .replace(/\n\s*\n(?:\s*\n)+/g, '\n\n') // merge 2+ blank lines
+        .replace(/CONTRACT_CLASS_NAME/g, content.contractClassName);
+}
+/**
+ * The main function: accepts top-level declarations from Tolk sources (converted to ABI)
+ * 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);
+    const declarationsBuf = new formatting_1.OutBuf();
+    for (const n of contract.declarations) {
+        try {
+            if (n.kind === 'struct')
+                tolkStructToTypeScript(ctx, n, declarationsBuf);
+            else if (n.kind === 'alias')
+                tolkAliasToTypeScript(ctx, n, declarationsBuf);
+            else if (n.kind === 'enum')
+                tolkEnumToTypeScript(ctx, n, declarationsBuf);
+            declarationsBuf.emptyLine();
+        }
+        catch (ex) {
+            throw new unsupported_errors_1.CantGenerateWrappersAtAll(`Error while generating ${n.kind.toLowerCase()} '${n.name}'`, ex);
+        }
+    }
+    let packUnpackSerializers = declarationsBuf.toString();
+    let createCellsMethodsStr = contract.incoming_messages.map(msg => generateCreateCellOfMessageMethod(ctx, msg.body_ty));
+    let sendMethodsStr = contract.incoming_messages.map(msg => {
+        try {
+            return generateSendMethod(ctx, msg.body_ty);
+        }
+        catch (ex) {
+            throw new unsupported_errors_1.CantGenerateWrappersAtAll(`Error while generating send method '${(0, types_kernel_1.renderTy)(msg.body_ty)}'`, ex);
+        }
+    });
+    let getMethodsStr = contract.get_methods.map(getM => {
+        try {
+            return generateGetMethod(ctx, getM);
+        }
+        catch (ex) {
+            throw new unsupported_errors_1.CantGenerateWrappersAtAll(`Error while generating get method '${getM.name}'`, ex);
+        }
+    });
+    let intNAliasesStr = ctx.sortOccurred(ctx.intNOccurred).map(intN => `type ${intN} = bigint`);
+    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},`);
+    return renderTsTemplate(out_template_generated_1.OUT_TEMPLATE, {
+        contractClassName: contract.contract_name,
+        flags: {
+            'has_sendDeploy': true,
+            'has_bitsN': ctx.bitsNOccurred.size > 0,
+            'has_varIntN': ctx.varIntNOccurred.size > 0,
+            'has_remaining': ctx.has_RemainingBitsAndRefs,
+            'has_customPackUnpack': ctx.has_customPackUnpack,
+            'has_customDictV': ctx.has_customDictV,
+            'has_implicitUnionPrefix': ctx.has_implicitUnionPrefix,
+            'has_non32Prefixes': ctx.has_non32Prefixes,
+            'has_addressAny': ctx.has_addressAny,
+            'has_arrayOf': ctx.has_arrayOf,
+            'has_lispListOf': ctx.has_lispListOf,
+            'stackReadsUnknown': ctx.stackReadsUnknown,
+            'stackReadsArrayOf': ctx.stackReadsArrayOf,
+            'stackReadsLispListOf': ctx.stackReadsLispListOf,
+            'stackReadsSnakeString': ctx.stackReadsSnakeString,
+            'stackReadsTuple': ctx.stackReadsTuple,
+            'stackReadsMapKV': ctx.stackReadsMapKV,
+            'stackReadsBuilder': ctx.stackReadsBuilder,
+            'stackReadsNullable': ctx.stackReadsNullable,
+            'stackReadsWideNullable': ctx.stackReadsWideNullable,
+            'stackReadsUnionType': ctx.stackReadsUnionType,
+            'stackReadsCellRef': ctx.stackReadsCellRef,
+            'stackReadsNullLiteral': ctx.stackReadsNullLiteral,
+        },
+        slots: {
+            'intNAliases': intNAliasesStr.join('\n'),
+            'uintNAliases': uintNAliasesStr.join('\n'),
+            'varIntNAliases': varIntNAliasesStr.join('\n'),
+            'sliceAliases': sliceAliasesStr.join('\n'),
+            'packUnpackSerializers': packUnpackSerializers,
+            'codeBoc64': contract.codeBoc64,
+            'errorCodes': errorCodesStr.join('\n'),
+            'fromStorageMethod': generateFromStorageMethod(ctx, contract.storage.storage_at_deployment_ty ?? contract.storage.storage_ty, contract.contract_name),
+            'createCellsMethods': createCellsMethodsStr.join('\n\n'),
+            'sendMethods': sendMethodsStr.join('\n\n'),
+            'getMethods': getMethodsStr.join('\n\n'),
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { generateTypeScriptFileForContract } from './generate-ts-wrappers';
+export type { ContractABI, ABIGetMethod } from './abi';
+export type { ABIConstExpression, ABIAlias, ABIEnum, ABIStruct, Ty, } from './abi-types';
+export { CantGeneratePackUnpack, CantGenerateWrappersAtAll, NonStandardDictKey, NotSupportedTypeOnStack, SymbolNotFound, } from './unsupported-errors';

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolNotFound = exports.NotSupportedTypeOnStack = exports.NonStandardDictKey = exports.CantGenerateWrappersAtAll = exports.CantGeneratePackUnpack = 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 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; } });
+Object.defineProperty(exports, "NonStandardDictKey", { enumerable: true, get: function () { return unsupported_errors_1.NonStandardDictKey; } });
+Object.defineProperty(exports, "NotSupportedTypeOnStack", { enumerable: true, get: function () { return unsupported_errors_1.NotSupportedTypeOnStack; } });
+Object.defineProperty(exports, "SymbolNotFound", { enumerable: true, get: function () { return unsupported_errors_1.SymbolNotFound; } });

package/dist/out-template.generated.d.ts

@@ -0,0 +1 @@
+export declare const OUT_TEMPLATE = "// AUTO-GENERATED, do not edit\n// it's a TypeScript wrapper for a CONTRACT_CLASS_NAME contract in Tolk\n/* eslint-disable */\n\nimport * as c from '@ton/core';\nimport { beginCell, ContractProvider, Sender, SendMode } from '@ton/core';\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   predefined types and functions\n//\n\n// {{if:has_remaining}}\ntype RemainingBitsAndRefs = c.Slice\n// {{/if:has_remaining}}\n\n// {{if:has_addressAny}}\nexport type any_address = c.Address | c.ExternalAddress | 'none'\n// {{/if:has_addressAny}}\n\n// {{if:has_arrayOf}}\ntype array<T> = T[]\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\n// TypeScript wrappers flatten a TVM linked list `[1 [2 [3 null]]]` to `[1 2 3]`\ntype lisp_list<T> = T[]\n// {{/if:has_lispListOf}}\n\ntype StoreCallback<T> = (obj: T, b: c.Builder) => void\ntype LoadCallback<T> = (s: c.Slice) => T\n\nexport type CellRef<T> = {\n    ref: T\n}\n\nfunction makeCellFrom<T>(self: T, storeFn_T: StoreCallback<T>): c.Cell {\n    let b = beginCell();\n    storeFn_T(self, b);\n    return b.endCell();\n}\n\nfunction loadAndCheckPrefix32(s: c.Slice, expected: number, structName: string): void {\n    let prefix = s.loadUint(32);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected 0x${expected.toString(16).padStart(8, '0')}, got 0x${prefix.toString(16).padStart(8, '0')}`);\n    }\n}\n\n// {{if:has_non32Prefixes}}\nfunction formatPrefix(prefixNum: number, prefixLen: number): string {\n    return prefixLen % 4 ? `0b${prefixNum.toString(2).padStart(prefixLen, '0')}` : `0x${prefixNum.toString(16).padStart(prefixLen / 4, '0')}`;\n}\n\nfunction loadAndCheckPrefix(s: c.Slice, expected: number, prefixLen: number, structName: string): void {\n    let prefix = s.loadUint(prefixLen);\n    if (prefix !== expected) {\n        throw new Error(`Incorrect prefix for '${structName}': expected ${formatPrefix(expected, prefixLen)}, got ${formatPrefix(prefix, prefixLen)}`);\n    }\n}\n// {{/if:has_non32Prefixes}}\n\nfunction lookupPrefix(s: c.Slice, expected: number, prefixLen: number): boolean {\n    return s.remainingBits >= prefixLen && s.preloadUint(prefixLen) === expected;\n}\n\n// {{if:has_implicitUnionPrefix}}\nfunction lookupPrefixAndEat(s: c.Slice, expected: number, prefixLen: number): boolean {\n    if (lookupPrefix(s, expected, prefixLen)) {\n        s.skip(prefixLen);\n        return true;\n    }\n    return false;\n}\n// {{/if:has_implicitUnionPrefix}}\n\nfunction throwNonePrefixMatch(fieldPath: string): never {\n    throw new Error(`Incorrect prefix for '${fieldPath}': none of variants matched`);\n}\n\nfunction storeCellRef<T>(cell: CellRef<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let b_ref = c.beginCell();\n    storeFn_T(cell.ref, b_ref);\n    b.storeRef(b_ref.endCell());\n}\n\nfunction loadCellRef<T>(s: c.Slice, loadFn_T: LoadCallback<T>): CellRef<T> {\n    let s_ref = s.loadRef().beginParse();\n    return { ref: loadFn_T(s_ref) };\n}\n\n// {{if:has_addressAny}}\nfunction storeTolkAddressAny(a: any_address, b: c.Builder): void {\n    let maybe_addr = a === 'none' ? null : a;\n    b.storeAddress(maybe_addr);\n}\n\nfunction loadTolkAddressAny(s: c.Slice): any_address {\n    let maybe_addr = s.loadAddressAny();\n    return maybe_addr === null ? 'none' : maybe_addr;\n}\n// {{/if:has_addressAny}}\n\n// {{if:has_bitsN}}\nfunction storeTolkBitsN(v: c.Slice, nBits: number, b: c.Builder): void {\n    if (v.remainingBits !== nBits) { throw new Error(`expected ${nBits} bits, got ${v.remainingBits}`); }\n    if (v.remainingRefs !== 0) { throw new Error(`expected 0 refs, got ${v.remainingRefs}`); }\n    b.storeSlice(v);\n}\n\nfunction loadTolkBitsN(s: c.Slice, nBits: number): c.Slice {\n    return new c.Slice(new c.BitReader(s.loadBits(nBits)), []);\n}\n// {{/if:has_bitsN}}\n\n// {{if:has_remaining}}\nfunction storeTolkRemaining(v: RemainingBitsAndRefs, b: c.Builder): void {\n    b.storeSlice(v);\n}\n\nfunction loadTolkRemaining(s: c.Slice): RemainingBitsAndRefs {\n    let rest = s.clone();\n    s.loadBits(s.remainingBits);\n    while (s.remainingRefs) {\n        s.loadRef();\n    }\n    return rest;\n}\n// {{/if:has_remaining}}\n\nfunction storeTolkNullable<T>(v: T | null, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    if (v === null) {\n        b.storeUint(0, 1);\n    } else {\n        b.storeUint(1, 1);\n        storeFn_T(v, b);\n    }\n}\n\n// {{if:has_arrayOf}}\nfunction storeArrayOf<T>(v: array<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    // the compiler stores array<T> in chunks; in TypeScript, for simplicity, store \"1 elem = 1 ref\"\n    let tail = null as c.Cell | null;\n    for (let i = 0; i < v.length; ++i) {\n        let chunkB = beginCell().storeMaybeRef(tail);\n        storeFn_T(v[v.length - 1 - i], chunkB);\n        tail = chunkB.endCell();\n    }\n    b.storeUint(v.length, 8);\n    b.storeMaybeRef(tail);\n}\n\nfunction loadArrayOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): array<T> {\n    let len = s.loadUint(8);\n    let head = s.loadMaybeRef();\n    let outArr = [] as array<T>;\n    while (head != null) {\n        let s = head.beginParse();\n        head = s.loadMaybeRef();\n        while (s.remainingBits || s.remainingRefs) {\n            outArr.push(loadFn_T(s));\n        }\n    }\n    if (len !== outArr.length) {\n        throw new Error(`mismatch array binary data: expected ${len} elements, got ${outArr.length}`);\n    }\n    return outArr;\n}\n// {{/if:has_arrayOf}}\n\n// {{if:has_lispListOf}}\nfunction storeLispListOf<T>(v: lisp_list<T>, b: c.Builder, storeFn_T: StoreCallback<T>): void {\n    let tail = c.Cell.EMPTY;\n    for (let i = 0; i < v.length; ++i) {\n        let itemB = beginCell();\n        storeFn_T(v[i], itemB);\n        tail = itemB.storeRef(tail).endCell();\n    }\n    b.storeRef(tail);\n}\n\nfunction loadLispListOf<T>(s: c.Slice, loadFn_T: LoadCallback<T>): lisp_list<T> {\n    let outArr = [] as lisp_list<T>;\n    let head = s.loadRef().beginParse();\n    while (head.remainingRefs) {\n        let tailSnaked = head.loadRef();\n        let headValue = loadFn_T(head);\n        head.endParse();    // ensure no data is present besides T\n        outArr.unshift(headValue);\n        head = tailSnaked.beginParse();\n    }\n    return outArr;\n}\n// {{/if:has_lispListOf}}\n\n// {{if:has_customDictV}}\nfunction createDictionaryValue<V>(loadFn_V: LoadCallback<V>, storeFn_V: StoreCallback<V>): c.DictionaryValue<V> {\n    return {\n        serialize(self: V, b: c.Builder) {\n            storeFn_V(self, b);\n        },\n        parse(s: c.Slice): V {\n            const value = loadFn_V(s);\n            s.endParse();\n            return value;\n        }\n    }\n}\n// {{/if:has_customDictV}}\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   parse get methods result from a TVM stack\n//\n\nclass StackReader {\n    constructor(private tuple: c.TupleItem[]) {\n    }\n\n    static fromGetMethod(expectedN: number, getMethodResult: { stack: c.TupleReader }): StackReader {\n        let tuple = [] as c.TupleItem[];\n        while (getMethodResult.stack.remaining) {\n            tuple.push(getMethodResult.stack.pop());\n        }\n        if (tuple.length !== expectedN) {\n            throw new Error(`expected ${expectedN} stack width, got ${tuple.length}`);\n        }\n        return new StackReader(tuple);\n    }\n\n    private popExpecting<ItemT>(itemType: string): ItemT {\n        const item = this.tuple.shift();\n        if (item?.type !== itemType) {\n            throw new Error(`not '${itemType}' on a stack`);\n        }\n        return item as ItemT;\n    }\n\n    readBigInt(): bigint {\n        return this.popExpecting<c.TupleItemInt>('int').value;\n    }\n\n    readBoolean(): boolean {\n        return this.popExpecting<c.TupleItemInt>('int').value !== 0n;\n    }\n\n    readCell(): c.Cell {\n        return this.popExpecting<c.TupleItemCell>('cell').cell;\n    }\n\n    readSlice(): c.Slice {\n        return this.popExpecting<c.TupleItemSlice>('slice').cell.beginParse();\n    }\n\n    // {{if:stackReadsBuilder}}\n    readBuilder(): c.Builder {\n        return beginCell().storeSlice(this.popExpecting<c.TupleItemBuilder>('builder').cell.beginParse());\n    }\n    // {{/if:stackReadsBuilder}}\n\n    // {{if:stackReadsUnknown}}\n    readUnknown(): c.TupleItem {\n        // `unknown` from Tolk is left as a raw tuple item\n        return this.tuple.shift()!;\n    }\n    // {{/if:stackReadsUnknown}}\n\n    // {{if:stackReadsArrayOf}}\n    readArrayOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        const subReader = new StackReader(subItems);\n        // array len N => N subItems => N calls to readFn_T\n        return [...subItems].map(_ => readFn_T(subReader));\n    }\n    // {{/if:stackReadsArrayOf}}\n\n    // {{if:stackReadsLispListOf}}\n    readLispListOf<T>(readFn_T: (nestedReader: StackReader) => T): T[] {\n        // read `[1 [2 [3 null]]]` to `[1 2 3]`\n        let pairReader: StackReader = this;\n        let outArr = [] as T[];\n        while (true) {\n            if (pairReader.tuple[0].type === 'null') {\n                pairReader.tuple.shift();\n                break;\n            }\n            let headAndTail = pairReader.popExpecting<c.Tuple>('tuple').items;\n            if (headAndTail.length !== 2) {\n                throw new Error(`malformed lisp_list, expected 2 stack width, got ${headAndTail.length}`);\n            }\n            pairReader = new StackReader(headAndTail);\n            outArr.push(readFn_T(pairReader));\n        }\n        return outArr;\n    }\n    // {{/if:stackReadsLispListOf}}\n\n    // {{if:stackReadsSnakeString}}\n    readSnakeString(): string {\n        return this.readCell().beginParse().loadStringTail();\n    }\n    // {{/if:stackReadsSnakeString}}\n\n    // {{if:stackReadsTuple}}\n    readTuple<T>(expectedN: number, readFn_T: (nestedReader: StackReader) => T): T {\n        const subItems = this.popExpecting<c.Tuple>('tuple').items;\n        if (subItems.length !== expectedN) {\n            throw new Error(`expected ${expectedN} items in a tuple, got ${subItems.length}`);\n        }\n        return readFn_T(new StackReader(subItems));\n    }\n    // {{/if:stackReadsTuple}}\n\n    // {{if:stackReadsNullLiteral}}\n    readNullLiteral(): null {\n        this.popExpecting<c.TupleItemNull>('null');\n        return null;\n    }\n    // {{/if:stackReadsNullLiteral}}\n\n    // {{if:stackReadsNullable}}\n    readNullable<T>(readFn_T: (r: StackReader) => T): T | null {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return null;\n        }\n        return readFn_T(this);\n    }\n    // {{/if:stackReadsNullable}}\n\n    // {{if:stackReadsWideNullable}}\n    readWideNullable<T>(stackW: number, readFn_T: (r: StackReader) => T): T | null {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        if (slotTypeId.value === 0n) {\n            this.tuple = this.tuple.slice(stackW);\n            return null;\n        }\n        const valueT = readFn_T(this);\n        this.tuple.shift();\n        return valueT;\n    }\n    // {{/if:stackReadsWideNullable}}\n\n    // {{if:stackReadsUnionType}}\n    readUnionType<T>(stackW: number, infoForTypeId: Record<number, [number, string | null, (r: StackReader) => any]>): T {\n        const slotTypeId = this.tuple[stackW - 1];\n        if (slotTypeId?.type !== 'int') {\n            throw new Error(`not 'int' on a stack`);\n        }\n        const info = infoForTypeId[Number(slotTypeId.value)];   // [stackWidth, label, readFn_T{i}]\n        if (info == null) {\n            throw new Error(`unexpected UTag=${slotTypeId.value}`);\n        }\n        const label = info[1];\n        this.tuple = this.tuple.slice(stackW - 1 - info[0]);\n        const valueT = info[2](this);\n        this.tuple.shift();\n        return label == null ? valueT : { $: label, value: valueT } as T;\n    }\n    // {{/if:stackReadsUnionType}}\n\n    // {{if:stackReadsCellRef}}\n    readCellRef<T>(loadFn_T: LoadCallback<T>): CellRef<T> {\n        return { ref: loadFn_T(this.readCell().beginParse()) };\n    }\n    // {{/if:stackReadsCellRef}}\n\n    // {{if:stackReadsMapKV}}\n    readDictionary<K extends c.DictionaryKeyTypes, V>(keySerializer: c.DictionaryKey<K>, valueSerializer: c.DictionaryValue<V>): c.Dictionary<K, V> {\n        if (this.tuple[0].type === 'null') {\n            this.tuple.shift();\n            return c.Dictionary.empty<K, V>(keySerializer, valueSerializer);\n        }\n        return c.Dictionary.loadDirect<K, V>(keySerializer, valueSerializer, this.readCell());\n    }\n    // {{/if:stackReadsMapKV}}\n}\n\n// {{if:has_customPackUnpack}}\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   custom packToBuilder and unpackFromSlice\n//\n\ntype CustomPackToBuilderFn<T> = (self: T, b: c.Builder) => void\ntype CustomUnpackFromSliceFn<T> = (s: c.Slice) => T\n\nlet customSerializersRegistry: Map<string, [CustomPackToBuilderFn<any> | null, CustomUnpackFromSliceFn<any> | null]> = new Map;\n\nfunction ensureCustomSerializerRegistered(typeName: string) {\n    if (!customSerializersRegistry.has(typeName)) {\n        throw new Error(`Custom packToBuilder/unpackFromSlice was not registered for type 'CONTRACT_CLASS_NAME.${typeName}'.\\n(in Tolk code, they have custom logic \\`fun ${typeName}__packToBuilder\\`)\\nSteps to fix:\\n1) in your code, create and implement\\n > function ${typeName}__packToBuilder(self: ${typeName}, b: Builder): void { ... }\\n > function ${typeName}__unpackFromSlice(s: Slice): ${typeName} { ... }\\n2) register them in advance by calling\\n > CONTRACT_CLASS_NAME.registerCustomPackUnpack('${typeName}', ${typeName}__packToBuilder, ${typeName}__unpackFromSlice);`);\n    }\n}\n\nfunction invokeCustomPackToBuilder<T>(typeName: string, self: T, b: c.Builder) {\n    ensureCustomSerializerRegistered(typeName);\n    customSerializersRegistry.get(typeName)![0]!(self, b);\n}\n\nfunction invokeCustomUnpackFromSlice<T>(typeName: string, s: c.Slice): T {\n    ensureCustomSerializerRegistered(typeName);\n    return customSerializersRegistry.get(typeName)![1]!(s);\n}\n// {{/if:has_customPackUnpack}}\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//   auto-generated serializers to/from cells\n//\n\ntype coins = bigint\n\n// {{intNAliases}}\n\n// {{uintNAliases}}\n\n// {{if:has_varIntN}}\n// {{varIntNAliases}}\n// {{/if:has_varIntN}}\n\n// {{if:has_bitsN}}\n// {{sliceAliases}}\n// {{/if:has_bitsN}}\n\n// {{packUnpackSerializers}}\n\n// \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\n//    class CONTRACT_CLASS_NAME\n//\n\ninterface ExtraSendOptions {\n    bounce?: boolean                    // default: false\n    sendMode?: SendMode                 // default: SendMode.PAY_GAS_SEPARATELY\n    extraCurrencies?: c.ExtraCurrency   // default: empty dict\n}\n\ninterface DeployedAddrOptions {\n    workchain?: number                  // default: 0 (basechain)\n    toShard?: { fixedPrefixLength: number; closeTo: c.Address }\n    overrideContractCode?: c.Cell\n}\n\nfunction calculateDeployedAddress(code: c.Cell, data: c.Cell, options: DeployedAddrOptions): c.Address {\n    const stateInitCell = beginCell().store(c.storeStateInit({\n        code,\n        data,\n        splitDepth: options.toShard?.fixedPrefixLength,\n        special: null,          // todo will somebody need special?\n        libraries: null,        // todo will somebody need libraries?\n    })).endCell();\n\n    let addrHash = stateInitCell.hash();\n    if (options.toShard) {\n        const shardDepth = options.toShard.fixedPrefixLength;\n        addrHash = beginCell()  // todo any way to do it better? N bits from closeTo + 256-N from stateInitCell\n            .storeBits(new c.BitString(options.toShard.closeTo.hash, 0, shardDepth))\n            .storeBits(new c.BitString(stateInitCell.hash(), shardDepth, 256 - shardDepth))\n            .endCell()\n            .beginParse().loadBuffer(32);\n    }\n\n    return new c.Address(options.workchain ?? 0, addrHash);\n}\n\nexport class CONTRACT_CLASS_NAME implements c.Contract {\n    static CodeCell = c.Cell.fromBase64('{{codeBoc64}}');\n\n    static Errors = {\n        // {{errorCodes}}\n    }\n\n    readonly address: c.Address\n    readonly init?: { code: c.Cell, data: c.Cell }\n\n    private constructor(address: c.Address, init?: { code: c.Cell, data: c.Cell }) {\n        this.address = address;\n        this.init = init;\n    }\n\n    // {{if:has_customPackUnpack}}\n    static registerCustomPackUnpack<T>(\n        typeName: string,\n        packToBuilderFn: CustomPackToBuilderFn<T> | null,\n        unpackFromSliceFn: CustomUnpackFromSliceFn<T> | null,\n    ) {\n        if (customSerializersRegistry.has(typeName)) {\n            throw new Error(`Custom pack/unpack for 'CONTRACT_CLASS_NAME.${typeName}' already registered`);\n        }\n        customSerializersRegistry.set(typeName, [packToBuilderFn, unpackFromSliceFn]);\n    }\n    // {{/if:has_customPackUnpack}}\n\n    static fromAddress(address: c.Address) {\n        return new CONTRACT_CLASS_NAME(address);\n    }\n\n    // {{fromStorageMethod}}\n\n    // {{createCellsMethods}}\n\n    // {{if:has_sendDeploy}}\n    async sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions) {\n        return provider.internal(via, {\n            value: msgValue,\n            body: c.Cell.EMPTY,\n            ...extraOptions\n        });\n    }\n    // {{/if:has_sendDeploy}}\n\n    // {{sendMethods}}\n\n    // {{getMethods}}\n}\n";