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

package/README.md

@@ -1,47 +1,73 @@
-# Tolk-to-TypeScript wrappers generator (alpha)
+# gen-typescript-from-tolk-dev
 
-Currently, it uses a patched LSP to parse and Tolk source code (for MVP). Later, the compiler will be able
-to emit ABI of a contract, and LSP won't be used in this process.
+Generate production-ready TypeScript wrappers from a prebuilt Tolk ABI.
 
-### Main CLI
-
-The main entrypoint accepts contract ABI as a JSON string and prints the generated TypeScript wrapper to stdout:
+## Install
 
 ```bash
-npx gen-typescript-from-tolk '{"contractName":"MyContract", ... }'
+npm install gen-typescript-from-tolk-dev
+```
+
+## Library usage
+
+```ts
+import { generateTypeScriptFileForContract } from 'gen-typescript-from-tolk-dev';
+import type { ContractABI } from 'gen-typescript-from-tolk-dev';
+
+const abi: ContractABI = getAbiFromSomewhereElse();
+const wrapperSource = generateTypeScriptFileForContract(abi);
 ```
 
-This package no longer bundles a Tolk compiler. It only supports `ABI JSON -> TypeScript wrapper`.
+The generator expects ABI that already contains the contract metadata needed for wrapper emission, including `codeBoc64`.
 
+Generated wrappers import `@ton/core`, so the project that uses the generated wrapper file should have `@ton/core` installed.
 
-### Configuring TypeScript output
+## CLI usage
 
-1. All structs/aliases/enums are generated to the output — it's unconfigurable currently. 
-If a struct can't be serialized (contains `int` for example, not int32/uint64),
-its `fromSlice` and `store` just contain `throw new Error` with a description.
+Print wrapper code to `stdout`:
 
-2. Default values of all structs are preserved:
+```bash
+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=="}'
+```
+
+Write to a file:
+
+```bash
+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
 ```
-struct WalletStorage {
-    jettonBalance: coins = 0    // <----
-    ownerAddress: address
-    minterAddress: address
-}
+
+Read ABI JSON from `stdin`:
+
+```bash
+cat ./MyContract.abi.json | npx gen-typescript-from-tolk-dev - --out ./MyContract.ts
 ```
 
-Then, `jettonBalance` key in `WalletStorage.create()` will be optional. If it's a storage or a message, it will also be optional in `fromStorage` and `sendXXX`.
+Read ABI JSON from a file:
 
-3. If your storage change shape after initialization (the case of NFT), you can specify an "uninited storage" shape:
+```bash
+npx gen-typescript-from-tolk-dev --abi-file ./MyContract.abi.json --out ./MyContract.ts
 ```
-type NOT_INITIALIZED_STORAGE = StorageStructNotInitialized
+
+This matches the `emulator-rs` integration model: `npx <package> '<abi-json>'`, with the generated wrapper emitted to `stdout`.
+
+## Acton Compatibility
+
+The published package also exposes compatibility subpaths used by `emulator-rs`, for example:
+
+```ts
+import type { ContractABI } from 'gen-typescript-from-tolk-dev/src/abi';
+import { DynamicCtx } from 'gen-typescript-from-tolk-dev/src/dynamic-ctx';
+import { unpackFromSliceDynamic } from 'gen-typescript-from-tolk-dev/src/dynamic-serialization';
 ```
 
-Then, `fromStorage` will accept fields from this struct, not from `STORAGE`.
+## Development
 
+```bash
+npm run build
+npm test
+npm pack --dry-run
+```
 
-### Known issues
+Local tests and dev scripts compile `.tolk` files through `@ton/tolk-js`, but that compiler is intentionally not part of the published runtime package.
 
-1. Generics behave incorrectly when `T` is used inside unions (because generics are not monomorphic, they are true TypeScript generics). For example, you have `struct A<T> { v: T | int8 }` and instantiate `A<int2 | int4>`, then an actual prefix tree will be '00/01/10', but a TS wrapper serializes '0+T/1'; or, for `A<int8>` actually will be no union (`int8 | int8` = `int8`), but a TS wrapper will still serialize as '0+int8/1'. Similar corner cases appear in get methods that work via the stack. For example, `struct MyNullable<T> { v: T? }`, instantiated as `MyNullable<Point>` has no information about stack layout and type-id.
-2. Non-standard keys for maps are unsupported, like `map<Point, ...>`. Only intN/uintN/address are supported (99% use cases). Others can not be represented via `@ton/core` library at all.
-3. Custom serializers for generic structs `fun Some<T>.packToBuilder` not supported (works perfectly for non-generic structs and aliases, but not for generic).
-4. Default values for struct fields, if a field contains a union, not supported.
+The published npm package includes `dist/`, `bin/`, and `README.md`.

package/bin/generator.js

@@ -1,15 +1,3 @@
 #!/usr/bin/env node
 
-const path = require('path');
-require('ts-node').register({
-    transpileOnly: true,
-    project: path.join(__dirname, '..', 'tsconfig.json'),
-});
-
-require('../src/cli-generate-from-abi-json')
-    .runGeneratorFromAbiCli(process.argv.slice(2))
-    .catch((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`${message}\n`);
-        process.exitCode = 1;
-    });
+require('../dist/cli.js').main(process.argv.slice(2));

package/dist/abi-types.d.ts

@@ -0,0 +1,169 @@
+type bigint_as_string = string;
+export type Ty = {
+    kind: 'int';
+} | {
+    kind: 'intN';
+    n: number;
+} | {
+    kind: 'uintN';
+    n: number;
+} | {
+    kind: 'varintN';
+    n: number;
+} | {
+    kind: 'varuintN';
+    n: number;
+} | {
+    kind: 'coins';
+} | {
+    kind: 'bool';
+} | {
+    kind: 'cell';
+} | {
+    kind: 'builder';
+} | {
+    kind: 'slice';
+} | {
+    kind: 'string';
+} | {
+    kind: 'remaining';
+} | {
+    kind: 'address';
+} | {
+    kind: 'addressOpt';
+} | {
+    kind: 'addressExt';
+} | {
+    kind: 'addressAny';
+} | {
+    kind: 'bitsN';
+    n: number;
+} | {
+    kind: 'nullLiteral';
+} | {
+    kind: 'callable';
+} | {
+    kind: 'void';
+} | {
+    kind: 'unknown';
+} | {
+    kind: 'nullable';
+    inner: Ty;
+    stack_type_id?: number;
+    stack_width?: number;
+} | {
+    kind: 'cellOf';
+    inner: Ty;
+} | {
+    kind: 'arrayOf';
+    inner: Ty;
+} | {
+    kind: 'lispListOf';
+    inner: Ty;
+} | {
+    kind: 'tensor';
+    items: Ty[];
+} | {
+    kind: 'shapedTuple';
+    items: Ty[];
+} | {
+    kind: 'mapKV';
+    k: Ty;
+    v: Ty;
+} | {
+    kind: 'EnumRef';
+    enum_name: string;
+} | {
+    kind: 'StructRef';
+    struct_name: string;
+    type_args?: Ty[];
+} | {
+    kind: 'AliasRef';
+    alias_name: string;
+    type_args?: Ty[];
+} | {
+    kind: 'genericT';
+    name_t: string;
+} | {
+    kind: 'union';
+    variants: UnionVariant[];
+    stack_width: number;
+};
+export interface UnionVariant {
+    variant_ty: Ty;
+    prefix_str: string;
+    prefix_len: number;
+    is_prefix_implicit?: boolean;
+    stack_type_id: number;
+    stack_width: number;
+}
+export type ABIConstExpression = {
+    kind: 'int';
+    v: bigint_as_string;
+} | {
+    kind: 'bool';
+    v: boolean;
+} | {
+    kind: 'slice';
+    hex: string;
+} | {
+    kind: 'string';
+    str: string;
+} | {
+    kind: 'address';
+    addr: string;
+} | {
+    kind: 'tensor';
+    items: ABIConstExpression[];
+} | {
+    kind: 'shapedTuple';
+    items: ABIConstExpression[];
+} | {
+    kind: 'object';
+    struct_name: string;
+    fields: ABIConstExpression[];
+} | {
+    kind: 'castTo';
+    inner: ABIConstExpression;
+    cast_to: Ty;
+} | {
+    kind: 'null';
+};
+export interface ABICustomSerializers {
+    pack_to_builder: boolean;
+    unpack_from_slice: boolean;
+}
+export interface ABIStruct {
+    kind: 'struct';
+    name: string;
+    type_params?: string[];
+    prefix?: {
+        prefix_str: string;
+        prefix_len: number;
+    };
+    fields: {
+        name: string;
+        ty: Ty;
+        default_value?: ABIConstExpression;
+        description?: string;
+    }[];
+    custom_pack_unpack?: ABICustomSerializers;
+}
+export interface ABIAlias {
+    kind: 'alias';
+    name: string;
+    target_ty: Ty;
+    type_params?: string[];
+    custom_pack_unpack?: ABICustomSerializers;
+}
+export interface ABIEnum {
+    kind: 'enum';
+    name: string;
+    encoded_as: Ty;
+    members: {
+        name: string;
+        value: bigint_as_string;
+    }[];
+    custom_pack_unpack?: ABICustomSerializers;
+}
+export {};

package/dist/abi-types.js

@@ -0,0 +1,8 @@
+"use strict";
+/*
+    ABI Types — describes the type system and symbols definitions in the Tolk language.
+    The goal is to have a full bidirectional mapping from any Tolk struct to ABI:
+  all tricky types like generics, aliases, inline unions, etc. should be supported.
+  Then, any input could be packed to a cell and unpacked back — exactly as it's done by the compiler.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/abi.d.ts

@@ -0,0 +1,53 @@
+import { Ty, ABIStruct, ABIAlias, ABIEnum, ABIConstExpression } from './abi-types';
+export interface ABIGetMethod {
+    tvm_method_id: number;
+    name: string;
+    parameters: {
+        name: string;
+        ty: Ty;
+        description?: string;
+        default_value?: ABIConstExpression;
+    }[];
+    return_ty: Ty;
+    description?: string;
+}
+export interface ABIInternalMessage {
+    body_ty: Ty;
+    description?: string;
+    minimal_msg_value?: number;
+    preferred_send_mode?: number;
+}
+export interface ABIExternalMessage {
+    body_ty: Ty;
+    description?: string;
+}
+export interface ABIOutgoingMessage {
+    body_ty: Ty;
+    description?: string;
+}
+export interface ABIStorage {
+    storage_ty?: Ty;
+    storage_at_deployment_ty?: Ty;
+}
+export interface ABIThrownError {
+    kind: 'plain_int' | 'constant' | 'enum_member';
+    name?: string;
+    err_code: number;
+}
+export interface ContractABI {
+    contract_name: string;
+    author?: string;
+    version?: string;
+    description?: string;
+    declarations: (ABIStruct | ABIAlias | ABIEnum)[];
+    storage: ABIStorage;
+    incoming_messages: ABIInternalMessage[];
+    incoming_external: ABIExternalMessage[];
+    outgoing_messages: ABIOutgoingMessage[];
+    emitted_events: ABIOutgoingMessage[];
+    get_methods: ABIGetMethod[];
+    thrown_errors: ABIThrownError[];
+    compiler_name: string;
+    compiler_version: string;
+    codeBoc64: string;
+}

package/dist/abi.js

@@ -0,0 +1,13 @@
+"use strict";
+/*
+    ABI of a contract describes how the contract is "seen" by external observers:
+  its get methods, incoming messages, etc.
+    Given an ABI, it becomes possible to
+    - post messages from a client, since ABI provides sufficient info for serialization
+    - generate wrappers for TypeScript and other languages
+    - render its storage in the explorer
+    - create a UI to interact with a contract from Web/IDE
+    - etc.
+    The ABI is emitted by the Tolk compiler, along with bytecode.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function runCli(argv: string[]): void;
+export declare function main(argv?: string[]): void;

package/dist/cli.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+exports.main = main;
+const fs_1 = __importDefault(require("fs"));
+const generate_ts_wrappers_1 = require("./generate-ts-wrappers");
+function printHelp() {
+    const help = [
+        `Usage:`,
+        `  gen-typescript-from-tolk-dev '{"contract_name":"MyContract",...}' [--out ./MyContract.ts]`,
+        `  gen-typescript-from-tolk-dev - [--out ./MyContract.ts]`,
+        `  gen-typescript-from-tolk-dev --abi-file ./MyContract.abi.json [--out ./MyContract.ts]`,
+        `Options:`,
+        `  --abi-file <path>  read ABI JSON from a file`,
+        `  --out <path>       write output to a file; if missing, stdout is used`,
+        `  -                  read ABI JSON from stdin`,
+        `  --help, -h         show this help`,
+    ].join('\n');
+    process.stdout.write(`${help}\n`);
+}
+function parseArgs(argv) {
+    const args = [...argv];
+    const options = { showHelp: false };
+    while (args.length > 0) {
+        const arg = args.shift();
+        if (arg === '--help' || arg === '-h') {
+            options.showHelp = true;
+            continue;
+        }
+        if (arg === '--abi-file') {
+            const abiFile = args.shift();
+            if (!abiFile) {
+                throw new Error("Missing value for '--abi-file'");
+            }
+            if (options.abiJsonArg !== undefined || options.abiFile !== undefined) {
+                throw new Error('Only one ABI input source is expected');
+            }
+            options.abiFile = abiFile;
+            continue;
+        }
+        if (arg === '--out') {
+            const outFile = args.shift();
+            if (!outFile) {
+                throw new Error("Missing value for '--out'");
+            }
+            options.outFile = outFile;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown option '${arg}'`);
+        }
+        if (options.abiJsonArg !== undefined || options.abiFile !== undefined) {
+            throw new Error('Only one ABI input source is expected');
+        }
+        options.abiJsonArg = arg;
+    }
+    return options;
+}
+function readAbiInput(options) {
+    if (options.abiFile) {
+        try {
+            return fs_1.default.readFileSync(options.abiFile, 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to read ABI file '${options.abiFile}': ${error.message || error}`);
+        }
+    }
+    if (options.abiJsonArg === '-') {
+        try {
+            return fs_1.default.readFileSync(0, 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to read ABI JSON from stdin: ${error.message || error}`);
+        }
+    }
+    if (options.abiJsonArg !== undefined) {
+        return options.abiJsonArg;
+    }
+    throw new Error('ABI JSON argument is required');
+}
+function parseAbiJson(rawJson) {
+    try {
+        return JSON.parse(rawJson);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ABI JSON: ${error.message || error}`);
+    }
+}
+function writeOutput(output, outFile) {
+    if (outFile) {
+        fs_1.default.writeFileSync(outFile, output, 'utf-8');
+        process.stdout.write(`written ${outFile}\n`);
+        return;
+    }
+    process.stdout.write(output);
+}
+function runCli(argv) {
+    const options = parseArgs(argv);
+    if (options.showHelp) {
+        printHelp();
+        return;
+    }
+    const abi = parseAbiJson(readAbiInput(options));
+    const generated = (0, generate_ts_wrappers_1.generateTypeScriptFileForContract)(abi);
+    writeOutput(generated, options.outFile);
+}
+function main(argv = process.argv.slice(2)) {
+    try {
+        runCli(argv);
+    }
+    catch (ex) {
+        process.stderr.write(`${ex.message || ex}\n`);
+        process.exitCode = 1;
+    }
+}
+if (require.main === module) {
+    main();
+}

package/dist/codegen-ctx.d.ts

@@ -0,0 +1,66 @@
+import type { Ty, ABIStruct, ABIAlias, ABIEnum } from './abi-types';
+export declare const RUNTIME: {
+    beginCell: string;
+    lookupPrefix: string;
+    lookupPrefixAndEat: string;
+    throwNonePrefixMatch: string;
+    loadAndCheckPrefix32: string;
+    loadAndCheckPrefix: string;
+    loadTolkBitsN: string;
+    storeTolkBitsN: string;
+    loadTolkAddressAny: string;
+    storeTolkAddressAny: string;
+    loadTolkRemaining: string;
+    storeTolkRemaining: string;
+    loadCellRef: string;
+    storeCellRef: string;
+    loadArrayOf: string;
+    storeArrayOf: string;
+    loadLispListOf: string;
+    storeLispListOf: string;
+    storeTolkNullable: string;
+    makeCellFrom: string;
+    createDictionaryValue: string;
+    registerCustomPackUnpack: string;
+    ExtraSendOptions: string;
+    StackReader: string;
+};
+export declare class SymTable {
+    private structs;
+    private aliases;
+    private enums;
+    constructor(declarations: (ABIStruct | ABIAlias | ABIEnum)[]);
+    getStruct(structName: string): ABIStruct;
+    getAlias(aliasName: string): ABIAlias;
+    getEnum(enumName: string): ABIEnum;
+    getAliasTarget(aliasName: string): Ty;
+}
+export declare class CodegenCtx {
+    readonly symbols: SymTable;
+    intNOccurred: Set<string>;
+    uintNOccurred: Set<string>;
+    varIntNOccurred: Set<string>;
+    bitsNOccurred: Set<string>;
+    has_RemainingBitsAndRefs: boolean;
+    has_customPackUnpack: boolean;
+    has_customDictV: boolean;
+    has_implicitUnionPrefix: boolean;
+    has_non32Prefixes: boolean;
+    has_addressAny: boolean;
+    has_arrayOf: boolean;
+    has_lispListOf: boolean;
+    stackReadsUnknown: boolean;
+    stackReadsArrayOf: boolean;
+    stackReadsLispListOf: boolean;
+    stackReadsSnakeString: boolean;
+    stackReadsTuple: boolean;
+    stackReadsMapKV: boolean;
+    stackReadsBuilder: boolean;
+    stackReadsNullable: boolean;
+    stackReadsWideNullable: boolean;
+    stackReadsUnionType: boolean;
+    stackReadsCellRef: boolean;
+    stackReadsNullLiteral: boolean;
+    constructor(declarations: (ABIStruct | ABIAlias | ABIEnum)[]);
+    sortOccurred(occurred: Set<string>): string[];
+}

package/dist/codegen-ctx.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodegenCtx = exports.SymTable = exports.RUNTIME = void 0;
+const unsupported_errors_1 = require("./unsupported-errors");
+// Functions implemented in an output template, used to detect name shadowing.
+exports.RUNTIME = {
+    beginCell: 'beginCell',
+    lookupPrefix: 'lookupPrefix',
+    lookupPrefixAndEat: 'lookupPrefixAndEat',
+    throwNonePrefixMatch: 'throwNonePrefixMatch',
+    loadAndCheckPrefix32: 'loadAndCheckPrefix32',
+    loadAndCheckPrefix: 'loadAndCheckPrefix',
+    loadTolkBitsN: 'loadTolkBitsN',
+    storeTolkBitsN: 'storeTolkBitsN',
+    loadTolkAddressAny: 'loadTolkAddressAny',
+    storeTolkAddressAny: 'storeTolkAddressAny',
+    loadTolkRemaining: 'loadTolkRemaining',
+    storeTolkRemaining: 'storeTolkRemaining',
+    loadCellRef: 'loadCellRef',
+    storeCellRef: 'storeCellRef',
+    loadArrayOf: 'loadArrayOf',
+    storeArrayOf: 'storeArrayOf',
+    loadLispListOf: 'loadLispListOf',
+    storeLispListOf: 'storeLispListOf',
+    storeTolkNullable: 'storeTolkNullable',
+    makeCellFrom: 'makeCellFrom',
+    createDictionaryValue: 'createDictionaryValue',
+    registerCustomPackUnpack: 'registerCustomPackUnpack',
+    ExtraSendOptions: 'ExtraSendOptions',
+    StackReader: 'StackReader',
+};
+// SymTable is an index of top-level declarations.
+class SymTable {
+    constructor(declarations) {
+        this.structs = new Map();
+        this.aliases = new Map();
+        this.enums = new Map();
+        for (const n of declarations) {
+            if (n.kind === 'struct')
+                this.structs.set(n.name, n);
+            else if (n.kind === 'alias')
+                this.aliases.set(n.name, n);
+            else if (n.kind === 'enum')
+                this.enums.set(n.name, n);
+        }
+    }
+    getStruct(structName) {
+        const s = this.structs.get(structName);
+        if (s === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('struct', structName);
+        return s;
+    }
+    getAlias(aliasName) {
+        const a = this.aliases.get(aliasName);
+        if (a === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('alias', aliasName);
+        return a;
+    }
+    getEnum(enumName) {
+        const e = this.enums.get(enumName);
+        if (e === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('enum', enumName);
+        return e;
+    }
+    getAliasTarget(aliasName) {
+        return this.getAlias(aliasName).target_ty;
+    }
+}
+exports.SymTable = SymTable;
+// CodegenCtx represents current state of TypeScript code generation.
+// It contains properties that affect final output and help resolve symbols.
+// For example, we want Tolk `int64` not be just TS `bigint`, but
+// to export `type int64 = bigint` and use `int64` directly,
+// that's why we track all occurred intN.
+// Same for other public properties, they are modified while iterating through declarations.
+class CodegenCtx {
+    constructor(declarations) {
+        this.intNOccurred = new Set(['int8', 'int16', 'int32', 'int256']);
+        this.uintNOccurred = new Set(['uint8', 'uint16', 'uint32', 'uint256']);
+        this.varIntNOccurred = new Set();
+        this.bitsNOccurred = new Set();
+        this.has_RemainingBitsAndRefs = false;
+        this.has_customPackUnpack = false;
+        this.has_customDictV = false;
+        this.has_implicitUnionPrefix = false;
+        this.has_non32Prefixes = false;
+        this.has_addressAny = false;
+        this.has_arrayOf = false;
+        this.has_lispListOf = false;
+        this.stackReadsUnknown = false;
+        this.stackReadsArrayOf = false;
+        this.stackReadsLispListOf = false;
+        this.stackReadsSnakeString = false;
+        this.stackReadsTuple = false;
+        this.stackReadsMapKV = false;
+        this.stackReadsBuilder = false;
+        this.stackReadsNullable = false;
+        this.stackReadsWideNullable = false;
+        this.stackReadsUnionType = false;
+        this.stackReadsCellRef = false;
+        this.stackReadsNullLiteral = false;
+        this.symbols = new SymTable(declarations);
+    }
+    sortOccurred(occurred) {
+        return [...occurred].sort((a, b) => a.length - b.length || a.localeCompare(b));
+    }
+}
+exports.CodegenCtx = CodegenCtx;

package/dist/dynamic-ctx.d.ts

@@ -0,0 +1,17 @@
+import * as c from '@ton/core';
+import { SymTable } from './codegen-ctx';
+import { ABIGetMethod, ContractABI } from './abi';
+type CustomPackToBuilderFn<T> = (self: T, b: c.Builder) => void;
+type CustomUnpackFromSliceFn<T> = (s: c.Slice) => T;
+export declare class DynamicCtx {
+    readonly contractName: string;
+    readonly getMethods: ABIGetMethod[];
+    readonly symbols: SymTable;
+    private customSerializersRegistry;
+    constructor(contract: ContractABI);
+    registerCustomPackUnpack<T>(typeName: string, packToBuilderFn: CustomPackToBuilderFn<T> | null, unpackFromSliceFn: CustomUnpackFromSliceFn<T> | null): void;
+    getCustomPackFnOrThrow(typeName: string, fieldPath: string): CustomPackToBuilderFn<any>;
+    getCustomUnpackFnOrThrow(typeName: string, fieldPath: string): CustomUnpackFromSliceFn<any>;
+    findGetMethod(getMethodName: string): ABIGetMethod | undefined;
+}
+export {};