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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (13) hide show
  1. package/README.md +8 -30
  2. package/dist/abi.d.ts +1 -0
  3. package/dist/cli.d.ts +0 -1
  4. package/dist/cli.js +10 -49
  5. package/dist/emit-stack-rw.js +1 -1
  6. package/dist/index.d.ts +5 -1
  7. package/dist/index.js +20 -1
  8. package/dist/out-template.generated.d.ts +1 -1
  9. package/dist/out-template.generated.js +1 -1
  10. package/package.json +6 -26
  11. package/bin/generator.js +0 -3
  12. package/dist/tolk-to-abi.d.ts +0 -2
  13. package/dist/tolk-to-abi.js +0 -22
package/README.md CHANGED
@@ -1,18 +1,18 @@
1
- # gen-typescript-from-tolk-dev
1
+ # gen-typescript-from-tolk
2
2
 
3
3
  Generate production-ready TypeScript wrappers from a prebuilt Tolk ABI.
4
4
 
5
5
  ## Install
6
6
 
7
7
  ```bash
8
- npm install gen-typescript-from-tolk-dev
8
+ npm install gen-typescript-from-tolk
9
9
  ```
10
10
 
11
11
  ## Library usage
12
12
 
13
13
  ```ts
14
- import { generateTypeScriptFileForContract } from 'gen-typescript-from-tolk-dev';
15
- import type { ContractABI } from 'gen-typescript-from-tolk-dev';
14
+ import { generateTypeScriptFileForContract } from 'gen-typescript-from-tolk';
15
+ import type { ContractABI } from 'gen-typescript-from-tolk';
16
16
 
17
17
  const abi: ContractABI = getAbiFromSomewhereElse();
18
18
  const wrapperSource = generateTypeScriptFileForContract(abi);
@@ -27,38 +27,16 @@ Generated wrappers import `@ton/core`, so the project that uses the generated wr
27
27
  Print wrapper code to `stdout`:
28
28
 
29
29
  ```bash
30
- npx gen-typescript-from-tolk-dev '{"contract_name":"MyContract","declarations":[],"storage":{},"incoming_messages":[],"incoming_external":[],"outgoing_messages":[],"emitted_events":[],"get_methods":[],"thrown_errors":[],"compiler_name":"tolk","compiler_version":"dev","codeBoc64":"te6ccgEBAQEAAgAAAA=="}'
30
+ npx gen-typescript-from-tolk '{"contractName":"MyContract","declarations":[],"storage":{},"incomingMessages":[],"incomingExternal":[],"outgoingMessages":[],"emittedEvents":[],"getMethods":[],"thrownErrors":[],"compilerName":"tolk","compilerVersion":"dev","codeBoc64":"te6ccgEBAQEAAgAAAA=="}'
31
31
  ```
32
32
 
33
33
  Write to a file:
34
34
 
35
35
  ```bash
36
- npx gen-typescript-from-tolk-dev '{"contract_name":"MyContract","declarations":[],"storage":{},"incoming_messages":[],"incoming_external":[],"outgoing_messages":[],"emitted_events":[],"get_methods":[],"thrown_errors":[],"compiler_name":"tolk","compiler_version":"dev","codeBoc64":"te6ccgEBAQEAAgAAAA=="}' --out ./MyContract.ts
36
+ npx gen-typescript-from-tolk '{"contractName":"MyContract","declarations":[],"storage":{},"incomingMessages":[],"incomingExternal":[],"outgoingMessages":[],"emittedEvents":[],"getMethods":[],"thrownErrors":[],"compilerName":"tolk","compilerVersion":"dev","codeBoc64":"te6ccgEBAQEAAgAAAA=="}' --out ./MyContract.ts
37
37
  ```
38
38
 
39
- Read ABI JSON from `stdin`:
40
-
41
- ```bash
42
- cat ./MyContract.abi.json | npx gen-typescript-from-tolk-dev - --out ./MyContract.ts
43
- ```
44
-
45
- Read ABI JSON from a file:
46
-
47
- ```bash
48
- npx gen-typescript-from-tolk-dev --abi-file ./MyContract.abi.json --out ./MyContract.ts
49
- ```
50
-
51
- This matches the `emulator-rs` integration model: `npx <package> '<abi-json>'`, with the generated wrapper emitted to `stdout`.
52
-
53
- ## Acton Compatibility
54
-
55
- The published package also exposes compatibility subpaths used by `emulator-rs`, for example:
56
-
57
- ```ts
58
- import type { ContractABI } from 'gen-typescript-from-tolk-dev/src/abi';
59
- import { DynamicCtx } from 'gen-typescript-from-tolk-dev/src/dynamic-ctx';
60
- import { unpackFromSliceDynamic } from 'gen-typescript-from-tolk-dev/src/dynamic-serialization';
61
- ```
39
+ You can also pass `-` instead of JSON to read ABI JSON from `stdin`.
62
40
 
63
41
  ## Development
64
42
 
@@ -70,4 +48,4 @@ npm pack --dry-run
70
48
 
71
49
  Local tests and dev scripts compile `.tolk` files through `@ton/tolk-js`, but that compiler is intentionally not part of the published runtime package.
72
50
 
73
- The published npm package includes `dist/`, `bin/`, and `README.md`.
51
+ Only `dist/` and `README.md` are included in the published npm package.
package/dist/abi.d.ts CHANGED
@@ -32,6 +32,7 @@ export interface ABIStorage {
32
32
  export interface ABIThrownError {
33
33
  kind: 'plain_int' | 'constant' | 'enum_member';
34
34
  name?: string;
35
+ description?: string;
35
36
  err_code: number;
36
37
  }
37
38
  export interface ContractABI {
package/dist/cli.d.ts CHANGED
@@ -1,3 +1,2 @@
1
1
  #!/usr/bin/env node
2
2
  export declare function runCli(argv: string[]): void;
3
- export declare function main(argv?: string[]): void;
package/dist/cli.js CHANGED
@@ -5,20 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
5
5
  };
6
6
  Object.defineProperty(exports, "__esModule", { value: true });
7
7
  exports.runCli = runCli;
8
- exports.main = main;
9
8
  const fs_1 = __importDefault(require("fs"));
10
9
  const generate_ts_wrappers_1 = require("./generate-ts-wrappers");
11
10
  function printHelp() {
12
11
  const help = [
13
12
  `Usage:`,
14
- ` gen-typescript-from-tolk-dev '{"contract_name":"MyContract",...}' [--out ./MyContract.ts]`,
15
- ` gen-typescript-from-tolk-dev - [--out ./MyContract.ts]`,
16
- ` gen-typescript-from-tolk-dev --abi-file ./MyContract.abi.json [--out ./MyContract.ts]`,
13
+ ` gen-typescript-from-tolk '{"contract_name":"MyContract",...}' --out ./MyContract.ts`,
17
14
  `Options:`,
18
- ` --abi-file <path> read ABI JSON from a file`,
19
- ` --out <path> write output to a file; if missing, stdout is used`,
20
- ` - read ABI JSON from stdin`,
21
- ` --help, -h show this help`,
15
+ ` --out — output file name; if missing, stdout is used`
22
16
  ].join('\n');
23
17
  process.stdout.write(`${help}\n`);
24
18
  }
@@ -31,17 +25,6 @@ function parseArgs(argv) {
31
25
  options.showHelp = true;
32
26
  continue;
33
27
  }
34
- if (arg === '--abi-file') {
35
- const abiFile = args.shift();
36
- if (!abiFile) {
37
- throw new Error("Missing value for '--abi-file'");
38
- }
39
- if (options.abiJsonArg !== undefined || options.abiFile !== undefined) {
40
- throw new Error('Only one ABI input source is expected');
41
- }
42
- options.abiFile = abiFile;
43
- continue;
44
- }
45
28
  if (arg === '--out') {
46
29
  const outFile = args.shift();
47
30
  if (!outFile) {
@@ -53,35 +36,13 @@ function parseArgs(argv) {
53
36
  if (arg.startsWith('--')) {
54
37
  throw new Error(`Unknown option '${arg}'`);
55
38
  }
56
- if (options.abiJsonArg !== undefined || options.abiFile !== undefined) {
57
- throw new Error('Only one ABI input source is expected');
39
+ if (options.abiJsonArg !== undefined) {
40
+ throw new Error('Only one ABI JSON argument is expected');
58
41
  }
59
42
  options.abiJsonArg = arg;
60
43
  }
61
44
  return options;
62
45
  }
63
- function readAbiInput(options) {
64
- if (options.abiFile) {
65
- try {
66
- return fs_1.default.readFileSync(options.abiFile, 'utf-8');
67
- }
68
- catch (error) {
69
- throw new Error(`Failed to read ABI file '${options.abiFile}': ${error.message || error}`);
70
- }
71
- }
72
- if (options.abiJsonArg === '-') {
73
- try {
74
- return fs_1.default.readFileSync(0, 'utf-8');
75
- }
76
- catch (error) {
77
- throw new Error(`Failed to read ABI JSON from stdin: ${error.message || error}`);
78
- }
79
- }
80
- if (options.abiJsonArg !== undefined) {
81
- return options.abiJsonArg;
82
- }
83
- throw new Error('ABI JSON argument is required');
84
- }
85
46
  function parseAbiJson(rawJson) {
86
47
  try {
87
48
  return JSON.parse(rawJson);
@@ -104,19 +65,19 @@ function runCli(argv) {
104
65
  printHelp();
105
66
  return;
106
67
  }
107
- const abi = parseAbiJson(readAbiInput(options));
68
+ if (!options.abiJsonArg) {
69
+ throw new Error("ABI JSON argument is required");
70
+ }
71
+ const abi = parseAbiJson(options.abiJsonArg);
108
72
  const generated = (0, generate_ts_wrappers_1.generateTypeScriptFileForContract)(abi);
109
73
  writeOutput(generated, options.outFile);
110
74
  }
111
- function main(argv = process.argv.slice(2)) {
75
+ if (require.main === module) {
112
76
  try {
113
- runCli(argv);
77
+ runCli(process.argv.slice(2));
114
78
  }
115
79
  catch (ex) {
116
80
  process.stderr.write(`${ex.message || ex}\n`);
117
81
  process.exitCode = 1;
118
82
  }
119
83
  }
120
- if (require.main === module) {
121
- main();
122
- }
package/dist/emit-stack-rw.js CHANGED
@@ -19,7 +19,7 @@ function emitStackReadExpr(ctx, fieldPath, ty, unTupleIfW = false) {
19
19
  ctx.stackReadsTuple || (ctx.stackReadsTuple = ty.kind === 'arrayOf' || ty.kind === 'lispListOf' || ty.kind === 'shapedTuple');
20
20
  ctx.stackReadsMapKV || (ctx.stackReadsMapKV = ty.kind === 'mapKV');
21
21
  ctx.stackReadsBuilder || (ctx.stackReadsBuilder = ty.kind === 'builder');
22
- ctx.stackReadsNullable || (ctx.stackReadsNullable = ty.kind === 'nullable' && ty.stack_type_id === undefined);
22
+ ctx.stackReadsNullable || (ctx.stackReadsNullable = ty.kind === 'nullable');
23
23
  ctx.stackReadsWideNullable || (ctx.stackReadsWideNullable = ty.kind === 'nullable' && ty.stack_type_id !== undefined);
24
24
  ctx.stackReadsUnionType || (ctx.stackReadsUnionType = ty.kind === 'union');
25
25
  ctx.stackReadsCellRef || (ctx.stackReadsCellRef = ty.kind === 'cellOf');
package/dist/index.d.ts CHANGED
@@ -1,4 +1,8 @@
1
1
  export { generateTypeScriptFileForContract } from './generate-ts-wrappers';
2
+ export { DynamicCtx } from './dynamic-ctx';
3
+ export { debugPrintFromStack } from './dynamic-debug-print';
4
+ export { callGetMethodDynamic, makeTvmTupleDynamic, StackReader, } from './dynamic-get-methods';
5
+ export { createTonCoreDictionaryKey, createTonCoreDictionaryValue, dynamicPack, dynamicUnpack, packToBuilderDynamic, unpackFromSliceDynamic, } from './dynamic-serialization';
2
6
  export type { ContractABI, ABIGetMethod } from './abi';
3
7
  export type { ABIConstExpression, ABIAlias, ABIEnum, ABIStruct, Ty, } from './abi-types';
4
- export { CantGeneratePackUnpack, CantGenerateWrappersAtAll, NonStandardDictKey, NotSupportedTypeOnStack, SymbolNotFound, } from './unsupported-errors';
8
+ export { CantGeneratePackUnpack, CantGenerateWrappersAtAll, CantCallGetMethodDynamic, CantPackDynamic, CantUnpackDynamic, InvalidDynamicInput, NonStandardDictKey, NotSupportedTypeOnStack, SymbolNotFound, } from './unsupported-errors';
package/dist/index.js CHANGED
@@ -1,11 +1,30 @@
1
1
  "use strict";
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
- exports.SymbolNotFound = exports.NotSupportedTypeOnStack = exports.NonStandardDictKey = exports.CantGenerateWrappersAtAll = exports.CantGeneratePackUnpack = exports.generateTypeScriptFileForContract = void 0;
3
+ 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;
4
4
  var generate_ts_wrappers_1 = require("./generate-ts-wrappers");
5
5
  Object.defineProperty(exports, "generateTypeScriptFileForContract", { enumerable: true, get: function () { return generate_ts_wrappers_1.generateTypeScriptFileForContract; } });
6
+ var dynamic_ctx_1 = require("./dynamic-ctx");
7
+ Object.defineProperty(exports, "DynamicCtx", { enumerable: true, get: function () { return dynamic_ctx_1.DynamicCtx; } });
8
+ var dynamic_debug_print_1 = require("./dynamic-debug-print");
9
+ Object.defineProperty(exports, "debugPrintFromStack", { enumerable: true, get: function () { return dynamic_debug_print_1.debugPrintFromStack; } });
10
+ var dynamic_get_methods_1 = require("./dynamic-get-methods");
11
+ Object.defineProperty(exports, "callGetMethodDynamic", { enumerable: true, get: function () { return dynamic_get_methods_1.callGetMethodDynamic; } });
12
+ Object.defineProperty(exports, "makeTvmTupleDynamic", { enumerable: true, get: function () { return dynamic_get_methods_1.makeTvmTupleDynamic; } });
13
+ Object.defineProperty(exports, "StackReader", { enumerable: true, get: function () { return dynamic_get_methods_1.StackReader; } });
14
+ var dynamic_serialization_1 = require("./dynamic-serialization");
15
+ Object.defineProperty(exports, "createTonCoreDictionaryKey", { enumerable: true, get: function () { return dynamic_serialization_1.createTonCoreDictionaryKey; } });
16
+ Object.defineProperty(exports, "createTonCoreDictionaryValue", { enumerable: true, get: function () { return dynamic_serialization_1.createTonCoreDictionaryValue; } });
17
+ Object.defineProperty(exports, "dynamicPack", { enumerable: true, get: function () { return dynamic_serialization_1.dynamicPack; } });
18
+ Object.defineProperty(exports, "dynamicUnpack", { enumerable: true, get: function () { return dynamic_serialization_1.dynamicUnpack; } });
19
+ Object.defineProperty(exports, "packToBuilderDynamic", { enumerable: true, get: function () { return dynamic_serialization_1.packToBuilderDynamic; } });
20
+ Object.defineProperty(exports, "unpackFromSliceDynamic", { enumerable: true, get: function () { return dynamic_serialization_1.unpackFromSliceDynamic; } });
6
21
  var unsupported_errors_1 = require("./unsupported-errors");
7
22
  Object.defineProperty(exports, "CantGeneratePackUnpack", { enumerable: true, get: function () { return unsupported_errors_1.CantGeneratePackUnpack; } });
8
23
  Object.defineProperty(exports, "CantGenerateWrappersAtAll", { enumerable: true, get: function () { return unsupported_errors_1.CantGenerateWrappersAtAll; } });
24
+ Object.defineProperty(exports, "CantCallGetMethodDynamic", { enumerable: true, get: function () { return unsupported_errors_1.CantCallGetMethodDynamic; } });
25
+ Object.defineProperty(exports, "CantPackDynamic", { enumerable: true, get: function () { return unsupported_errors_1.CantPackDynamic; } });
26
+ Object.defineProperty(exports, "CantUnpackDynamic", { enumerable: true, get: function () { return unsupported_errors_1.CantUnpackDynamic; } });
27
+ Object.defineProperty(exports, "InvalidDynamicInput", { enumerable: true, get: function () { return unsupported_errors_1.InvalidDynamicInput; } });
9
28
  Object.defineProperty(exports, "NonStandardDictKey", { enumerable: true, get: function () { return unsupported_errors_1.NonStandardDictKey; } });
10
29
  Object.defineProperty(exports, "NotSupportedTypeOnStack", { enumerable: true, get: function () { return unsupported_errors_1.NotSupportedTypeOnStack; } });
11
30
  Object.defineProperty(exports, "SymbolNotFound", { enumerable: true, get: function () { return unsupported_errors_1.SymbolNotFound; } });
package/dist/out-template.generated.d.ts CHANGED
@@ -1 +1 @@
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";
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 return item as ItemT;\n }\n throw new Error(`not '${itemType}' on a stack`);\n }\n\n private popCellLike(): c.Cell {\n const item = this.tuple.shift();\n if (item && (item.type === 'cell' || item.type === 'slice' || item.type === 'builder')) {\n return item.cell;\n }\n throw new Error(`not cell/slice on a stack`);\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.popCellLike();\n }\n\n readSlice(): c.Slice {\n return this.popCellLike().beginParse();\n }\n\n // {{if:stackReadsBuilder}}\n readBuilder(): c.Builder {\n return beginCell().storeSlice(this.popCellLike().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,\n libraries: null,\n })).endCell();\n\n let addrHash = stateInitCell.hash();\n if (options.toShard) {\n const shardDepth = options.toShard.fixedPrefixLength;\n addrHash = beginCell()\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";
package/dist/out-template.generated.js CHANGED
@@ -3,4 +3,4 @@
3
3
  // Source of truth: src/out-template.ts
4
4
  Object.defineProperty(exports, "__esModule", { value: true });
5
5
  exports.OUT_TEMPLATE = void 0;
6
- exports.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// ————————————————————————————————————————————\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// ————————————————————————————————————————————\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// ————————————————————————————————————————————\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// ————————————————————————————————————————————\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// ————————————————————————————————————————————\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";
6
+ exports.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// ————————————————————————————————————————————\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// ————————————————————————————————————————————\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 return item as ItemT;\n }\n throw new Error(`not '${itemType}' on a stack`);\n }\n\n private popCellLike(): c.Cell {\n const item = this.tuple.shift();\n if (item && (item.type === 'cell' || item.type === 'slice' || item.type === 'builder')) {\n return item.cell;\n }\n throw new Error(`not cell/slice on a stack`);\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.popCellLike();\n }\n\n readSlice(): c.Slice {\n return this.popCellLike().beginParse();\n }\n\n // {{if:stackReadsBuilder}}\n readBuilder(): c.Builder {\n return beginCell().storeSlice(this.popCellLike().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// ————————————————————————————————————————————\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// ————————————————————————————————————————————\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// ————————————————————————————————————————————\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,\n libraries: null,\n })).endCell();\n\n let addrHash = stateInitCell.hash();\n if (options.toShard) {\n const shardDepth = options.toShard.fixedPrefixLength;\n addrHash = beginCell()\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";
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "gen-typescript-from-tolk-dev",
3
- "version": "0.2.0",
3
+ "version": "0.2.3",
4
4
  "description": "Generate TypeScript wrappers from Tolk ABI",
5
5
  "author": "TON Core",
6
6
  "license": "MIT",
@@ -8,33 +8,16 @@
8
8
  "main": "./dist/index.js",
9
9
  "types": "./dist/index.d.ts",
10
10
  "exports": {
11
- ".": {
12
- "types": "./dist/index.d.ts",
13
- "import": "./dist/index.js",
14
- "require": "./dist/index.js",
15
- "default": "./dist/index.js"
16
- },
17
- "./src/*": {
18
- "types": "./dist/*.d.ts",
19
- "import": "./dist/*.js",
20
- "require": "./dist/*.js",
21
- "default": "./dist/*.js"
22
- },
11
+ ".": "./dist/index.js",
23
12
  "./package.json": "./package.json"
24
13
  },
25
- "typesVersions": {
26
- "*": {
27
- "src/*": [
28
- "dist/*"
29
- ]
30
- }
31
- },
32
14
  "files": [
33
- "bin",
34
15
  "dist",
35
16
  "README.md"
36
17
  ],
37
- "bin": "./bin/generator.js",
18
+ "bin": {
19
+ "gen-typescript-from-tolk": "./dist/cli.js"
20
+ },
38
21
  "sideEffects": false,
39
22
  "engines": {
40
23
  "node": ">=18"
@@ -57,14 +40,11 @@
57
40
  "typecheck": "npm run sync:template && tsc -p tsconfig.json",
58
41
  "test": "npm run sync:template && jest --config jest.config.js --verbose",
59
42
  "check": "npm run build && npm test",
60
- "pack:dry-run": "npm pack --dry-run",
61
43
  "prepack": "npm run build",
62
44
  "dev:codegen": "npm run sync:template && ts-node dev-codegen.ts"
63
45
  },
64
- "dependencies": {
65
- "@ton/core": "0.62.0"
66
- },
67
46
  "devDependencies": {
47
+ "@ton/core": "0.62.0",
68
48
  "@ton/crypto": "3.3.0",
69
49
  "@ton/sandbox": "0.37.2",
70
50
  "@ton/ton": "15.4.0",
package/bin/generator.js DELETED
@@ -1,3 +0,0 @@
1
- #!/usr/bin/env node
2
-
3
- require('../dist/cli.js').main(process.argv.slice(2));
package/dist/tolk-to-abi.d.ts DELETED
@@ -1,2 +0,0 @@
1
- import type { ContractABI } from './abi';
2
- export declare function convertTolkFileToABI(absFileName: string): Promise<ContractABI>;
package/dist/tolk-to-abi.js DELETED
@@ -1,22 +0,0 @@
1
- "use strict";
2
- var __importDefault = (this && this.__importDefault) || function (mod) {
3
- return (mod && mod.__esModule) ? mod : { "default": mod };
4
- };
5
- Object.defineProperty(exports, "__esModule", { value: true });
6
- exports.convertTolkFileToABI = convertTolkFileToABI;
7
- const fs_1 = __importDefault(require("fs"));
8
- const tolk_js_1 = require("@ton/tolk-js");
9
- // This function is used ONLY for development (when tolk-js is installed),
10
- // it is not exposed as public API.
11
- async function convertTolkFileToABI(absFileName) {
12
- let compileResult = await (0, tolk_js_1.runTolkCompiler)({
13
- entrypointFileName: absFileName,
14
- fsReadCallback: path => fs_1.default.readFileSync(path, 'utf-8'),
15
- });
16
- if (compileResult.status === 'error') {
17
- throw new Error(`Can not compile with tolk-js: ${compileResult.message}`);
18
- }
19
- let json = compileResult.abiJson;
20
- json.codeBoc64 = compileResult.codeBoc64;
21
- return json;
22
- }