gen-typescript-from-tolk-dev 0.1.0

package/src/out-template.ts

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

package/src/tolk-to-abi.ts

@@ -0,0 +1,5 @@
+import type { ContractABI } from './abi';
+
+export async function convertTolkFileToABI(_absFileName: string): Promise<ContractABI> {
+    throw new Error('Compiling .tolk files is not supported in this package build. Pass ABI JSON directly to the CLI.');
+}