@taqueria/plugin-contract-types 0.0.0-pr-91-a8fa7172

package/src/generator/contract-parser.ts

@@ -0,0 +1,358 @@
+import * as M from '@taquito/michel-codec';
+import { assertExhaustive, GenerateApiError, reduceFlatMap } from './common';
+
+export type TypedStorage = {
+    storage: {
+        kind: 'object';
+        raw: M.MichelsonType;
+        fields: TypedVar[];
+    };
+};
+export type TypedParameter = {
+    methods: TypedMethod[];
+};
+export type TypedMethod = {
+    name: string;
+    args: TypedVar[];
+};
+export type TypedVar = {
+    name?: string;
+    type: TypedType;
+};
+export type TypedType = {
+    raw: M.MichelsonType;
+    optional?: boolean;
+} & (
+        {
+            kind: 'unit';
+        } | {
+            kind: 'never';
+        } | {
+            kind: 'unknown';
+        } | {
+            kind: 'value';
+            value: string;
+            typescriptType: 'string' | 'boolean' | 'number' | 'Date';
+        } | {
+            kind: 'union';
+            union: TypedVar[];
+        } | {
+            kind: 'object';
+            fields: TypedVar[];
+        } | {
+            kind: 'array';
+            array: { item: TypedType };
+        } | {
+            kind: 'map';
+            map: { key: TypedType, value: TypedType, isBigMap: boolean };
+        }
+    );
+
+const toDebugSource = (node: M.MichelsonType) => {
+    return JSON.stringify(node);
+};
+
+export const parseContractStorage = (storage: M.MichelsonContractStorage): TypedStorage => {
+    const fields = storage.args
+        .map(x => visitVar(x))
+        .reduce(reduceFlatMap, []);
+
+    const fieldsSimple = fields.length === 1 && !fields[0].name && fields[0].type.kind === 'object' ? fields[0].type.fields : fields;
+
+    return {
+        storage: {
+            kind: `object`,
+            raw: storage as unknown as M.MichelsonType,
+            fields: fieldsSimple,
+        },
+    };
+};
+
+export const parseContractParameter = (parameter: M.MichelsonContractParameter): TypedParameter => {
+    return {
+        methods: parameter.args
+            .map(x => visitContractParameterEndpoint(x as MMethod))
+            .reduce(reduceFlatMap, []),
+    };
+};
+
+
+type MMethod = M.MichelsonTypeOr<[M.MichelsonType, M.MichelsonType]>;
+const visitContractParameterEndpoint = (node: MMethod): TypedMethod[] => {
+
+    // console.log('visitContractParameterEndpoint', { node });
+
+    // Sub endpoints (i.e. admin endpoints that are imported)
+    if (node.prim === `or`) {
+        return node.args.map(x => visitContractParameterEndpoint(x as MMethod)).reduce(reduceFlatMap, []);
+    }
+
+    // Sub endpoints as a list with a single or (i.e. admin endpoints that are imported)
+    if (node.prim === `list` && node.args.length as number === 1 && (node.args[0] as MMethod)?.prim === `or`) {
+        return node.args.map(x => visitContractParameterEndpoint(x as MMethod)).reduce(reduceFlatMap, []);
+    }
+
+    const nameRaw = node.annots?.[0];
+    const name = nameRaw?.startsWith('%') ? nameRaw.substr(1) : null;
+
+    if (!name) {
+        console.warn(`Unknown method: ${node.prim as string}`, { node, args: node.args });
+        return [];
+    }
+
+    const nodeType = visitType(node, { ignorePairName: node.prim === 'pair' });
+
+    // Method args are usually objects
+    if (nodeType.kind === 'object') {
+        return [{ name, args: nodeType.fields }];
+    }
+
+    // Simple methods can have a single unnamed argument
+    return [{
+        name,
+        args: [{ type: nodeType }],
+    }];
+};
+
+// type PrimOf<T extends M.MichelsonType> = T extends { prim: infer U } ? U : never;
+// type WithPrim<T extends M.MichelsonType, P extends PrimOf<T>> = T extends { prim: P } ? T : never;
+// const isPrimType = <TPrim extends PrimOf<M.MichelsonType>>(node: undefined | null | M.MichelsonType, prim: TPrim): node is WithPrim<M.MichelsonType, TPrim> => {
+//     return (node && 'prim' in node && node.prim === prim) || false;
+// };
+
+type MVarArgs = M.MichelsonType;
+const visitVar = (node: MVarArgs): TypedVar[] => {
+    const name = `annots` in node && node.annots?.length === 1 ? node.annots[0].substr(1) : undefined;
+    const type = visitType(node);
+
+    return [{
+        name,
+        type,
+    }];
+};
+
+type MType = M.MichelsonType;
+const visitType = (node: MType, options?: { ignorePairName?: boolean }): TypedType => {
+    // console.log('visitType', { node });
+    // const debug_source = toDebugSource(node);
+
+    // if (typeof node === `string`) {
+    //     return { kind: `value`, raw: node, value: node, typescriptType: `string` };
+    // }
+
+    if (!(`prim` in node)) {
+        // Unknown
+        console.error(`visitType no prim`, { node });
+        return { kind: `unknown`, raw: node };
+    }
+
+    // Union
+    if (node.prim === `or`) {
+        const unionVars = node.args.map(x => visitVar(x)).reduce(reduceFlatMap, []).map(x => x);
+
+        // Flatten with child unions
+        const union = unionVars.map(x => !x.name && x.type.kind === 'union' ? x.type.union : [x]).reduce(reduceFlatMap, []);
+        // const union = unionVars.map(x=>x.type);
+
+        // const union = unionVars.map(x => x.type);
+
+        // Flatten with child unions
+
+        // const rightSide = union[1];
+        // if (rightSide.kind === `union`) {
+        //     union.pop();
+        //     union.push(...rightSide.union);
+        // }
+
+        if (union.some(x => !x)) {
+            throw new GenerateApiError(`or: Some fields are null`, { node });
+        }
+        return {
+            kind: `union`,
+            raw: node,
+            union,
+        };
+    }
+
+    // Intersect
+    if (node.prim === `pair`) {
+        const fields = node.args.map(x => visitVar(x)).reduce(reduceFlatMap, []);
+        if (fields.some(x => !x)) {
+            throw new GenerateApiError(`pair: Some fields are null`, { node, args: node.args, fields });
+        }
+        if (fields.length !== 2) {
+            throw new GenerateApiError(`pair: Expected 2 items`, { node, length: fields.length, fields });
+        }
+
+        // Flatten with unnamed child pairs
+        const fieldsFlat = fields.map(x => (!x.name || options?.ignorePairName) && x.type.kind === 'object' ? x.type.fields : [x]).reduce(reduceFlatMap, []);
+
+        return {
+            kind: `object`,
+            raw: node,
+            fields: fieldsFlat,
+        };
+    }
+
+    // list
+    if (node.prim === `list`
+        || node.prim === `set`
+    ) {
+        if (node.args.length !== 1) {
+            throw new GenerateApiError(`list does not have 1 arg`, { node, args: node.args });
+        }
+
+        const arrayItem = visitType(node.args[0]);
+        if (!arrayItem) {
+            throw new GenerateApiError(`arrayItem are null`, { node, args: node.args, arrayItem });
+        }
+        return {
+            kind: `array`,
+            raw: node,
+            array: { item: arrayItem },
+        };
+    }
+
+    // map
+    if (node.prim === `map`
+        || node.prim === `big_map`
+    ) {
+        if (node.args.length !== 2) {
+            throw new GenerateApiError(`map does not have 2 args`, { node, args: node.args });
+        }
+
+        const mapKey = visitType(node.args[0]);
+        const mapValue = visitType(node.args[1]);
+        if (!mapKey || !mapValue) {
+            throw new GenerateApiError(`map is missing key or value`, { node, args: node.args, mapKey, mapValue });
+        }
+        return {
+            kind: `map`,
+            raw: node,
+            map: {
+                key: mapKey,
+                value: mapValue,
+                isBigMap: node.prim === `big_map`,
+            },
+        };
+    }
+
+    // option
+    if (node.prim === `option`) {
+        return {
+            ...visitType(node.args[0]),
+            optional: true,
+        };
+    }
+
+    // boolean
+    if (node.prim === `bool`) {
+        return {
+            kind: `value`,
+            raw: node,
+            value: node.prim,
+            typescriptType: `boolean`,
+        };
+    }
+
+    // numbers
+    if (node.prim === `nat`
+        || node.prim === `int`
+        || node.prim === `mutez`
+    ) {
+        return {
+            kind: `value`,
+            raw: node,
+            value: node.prim,
+            typescriptType: `number`,
+        };
+    }
+
+    // Date
+    if (node.prim === `timestamp`
+
+    ) {
+        return {
+            kind: `value`,
+            raw: node,
+            value: node.prim,
+            typescriptType: `Date`,
+        };
+    }
+
+    // strings
+    if (node.prim === `address`
+        || node.prim === `key`
+        || node.prim === `key_hash`
+        || node.prim === `chain_id`
+        || node.prim === `string`
+        || node.prim === `signature`
+        || node.prim === `ticket`
+        || node.prim === `bls12_381_fr`
+        || node.prim === `bls12_381_g1`
+        || node.prim === `bls12_381_g2`
+        || node.prim === `sapling_state`
+        || node.prim === `sapling_transaction`
+        || node.prim === `contract`
+    ) {
+        return {
+            kind: `value`,
+            raw: node,
+            value: node.prim,
+            typescriptType: `string`,
+        };
+    }
+
+
+    // void
+    if (node.prim === `unit`) {
+        return {
+            kind: `unit`,
+            raw: node,
+        };
+    }
+
+    // bytes?
+    if (node.prim === `bytes`) {
+        return {
+            kind: `value`,
+            raw: node,
+            value: node.prim,
+            typescriptType: `string`,
+        };
+    }
+
+    // misc?
+    if (node.prim === `lambda`
+        || node.prim === `operation`
+    ) {
+        return {
+            kind: `value`,
+            raw: node,
+            value: node.prim,
+            typescriptType: `string`,
+        };
+    }
+
+    // chest
+    if(node.prim === 'chest'){
+        throw new Error('Not Implemented: chest');
+    }
+    if(node.prim === 'chest_key'){
+        throw new Error('Not Implemented: chest_key');
+    }
+
+    // never
+    if (node.prim === `never`
+    ) {
+        return {
+            kind: `never`,
+            raw: node,
+        };
+    }
+
+
+    // Unknown
+    assertExhaustive(node, `Unknown type`);
+    throw new GenerateApiError(`Unknown type`, { node });
+};

package/src/generator/process.ts

@@ -0,0 +1,66 @@
+import * as M from '@taquito/michel-codec';
+import { GenerateApiError } from './common';
+import { parseContractStorage, parseContractParameter } from './contract-parser';
+import { SchemaOutput, toSchema } from './schema-output';
+import { TypescriptCodeOutput, toTypescriptCode, TypeAliasData, TypeUtilsData } from './typescript-output';
+
+const parseContractWithMinimalProtocolLevel = (contractScript: string, format: 'tz' | 'json', contractLevelIndex: number): { contract: M.MichelsonContract, protocol: { name: string, key: string } } => {
+    const contractLevels = [
+        { name: 'PsDELPH1', key: M.Protocol.PsDELPH1 },
+        { name: 'PtEdo2Zk', key: M.Protocol.PtEdo2Zk },
+        { name: 'PsFLorena', key: M.Protocol.PsFLorena },
+    ];
+
+    const protocol = contractLevels[contractLevelIndex];
+    if (!protocol) {
+        throw new GenerateApiError(`Could not parse contract script`, contractScript);
+    }
+
+    const p = new M.Parser({ protocol: protocol.key });
+
+    try {
+        const contract = (format === 'tz' ? p.parseScript(contractScript) : p.parseJSON(JSON.parse(contractScript))) as M.MichelsonContract;
+        if (contract) {
+            return {
+                contract,
+                protocol,
+            };
+        }
+    } catch {
+        // Ignore parse errors
+    }
+
+    // Try again with next level
+    return parseContractWithMinimalProtocolLevel(contractScript, format, contractLevelIndex + 1);
+};
+
+export const generateContractTypesFromMichelsonCode = (contractScript: string, contractName: string, format: 'tz' | 'json', typeAliasData: TypeAliasData, typeUtilsData: TypeUtilsData): {
+    schema: SchemaOutput;
+    typescriptCodeOutput: TypescriptCodeOutput;
+    parsedContract: M.MichelsonContract;
+    minimalProtocol: string;
+} => {
+
+    const p = new M.Parser({ protocol: M.Protocol.PsFLorena });
+
+    const { contract, protocol } = parseContractWithMinimalProtocolLevel(contractScript, format, 0);
+
+    const contractStorage = contract.find(x => x.prim === `storage`) as undefined | M.MichelsonContractStorage;
+    const contractParameter = contract.find(x => x.prim === `parameter`) as undefined | M.MichelsonContractParameter;
+
+    const storageResult = contractStorage && parseContractStorage(contractStorage);
+    const storage = storageResult ?? { storage: { kind: `object`, raw: { prim: `never` } as M.MichelsonType, fields: [] } };
+
+    const parameterResult = contractParameter && parseContractParameter(contractParameter);
+    const methods = parameterResult?.methods ?? [];
+    const schemaOutput = toSchema(methods);
+
+    const typescriptCode = toTypescriptCode(storage, methods, contractName, contract, protocol, typeAliasData, typeUtilsData);
+
+    return {
+        schema: schemaOutput,
+        typescriptCodeOutput: typescriptCode,
+        parsedContract: contract,
+        minimalProtocol: protocol.key,
+    };
+};

package/src/generator/schema-output.ts

@@ -0,0 +1,54 @@
+import { GenerateApiError } from './common';
+import { TypedMethod, TypedVar, TypedType } from './contract-parser';
+
+type SchemaObjectType = { [name: string]: SchemaType };
+type SchemaType = string | SchemaType[] | SchemaObjectType;
+type SchemaMethods = {
+    [name: string]: {
+        params: SchemaType;
+    };
+};
+export type SchemaOutput = {
+    schemaMethods: SchemaMethods;
+};
+
+export const toSchema = (methods: TypedMethod[]): SchemaOutput => {
+
+    const getSchemaObjectType = (vars: TypedVar[]) => {
+        // console.log('getSchemaObjectType', { vars });
+
+        if (vars.some(x => !x)) {
+            throw new GenerateApiError(`getSchemaObjectType has null vars`, { vars });
+        }
+
+        return vars.reduce((out, x, i) => {
+            out[x.name ?? i] = getSchemaType(x.type);
+            return out;
+        }, {} as SchemaObjectType);
+    };
+
+    const getSchemaType = (t: TypedType): SchemaType => {
+        // console.log('getSchemaType', { t });
+
+        return (t.kind === `value` && t.value ? t.value : null)
+            ?? (t.kind === `array` && t.array ? [getSchemaType(t.array.item)] : null)
+            ?? (t.kind === `map` && t.map ? [`map`, getSchemaType(t.map.key), getSchemaType(t.map.value)] : null)
+            ?? (t.kind === `object` && t.fields ? getSchemaObjectType(t.fields) : null)
+            ?? (t.kind === `unit` ? `unit` : null)
+            ?? (t.kind === `never` ? `never` : null)
+            ?? `${t.raw as unknown as string}`;
+    };
+
+    const schemaMethods = methods.reduce((out, x) => {
+        // console.log('schemaMethods', { x });
+
+        out[x.name] = {
+            params: x.args.length === 1 && !x.args[0].name ? getSchemaType(x.args[0].type) : getSchemaObjectType(x.args ?? []),
+        };
+        return out;
+    }, {} as SchemaMethods);
+
+    return {
+        schemaMethods,
+    };
+};