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

package/src/generator/typescript-output.ts

@@ -0,0 +1,239 @@
+import { assertExhaustive, GenerateApiError, reduceFlatMap } from './common';
+import { TypedStorage, TypedMethod, TypedType, TypedVar } from './contract-parser';
+
+export type TypescriptCodeOutput = {
+    typesFileContent: string;
+    contractCodeFileContent: string;
+    storage: string;
+    methods: string;
+    methodsObject: string;
+};
+
+export type TypeAliasData = {
+    mode: 'local',
+    fileContent?: string,
+} | {
+    mode: 'file' | 'library',
+    importPath?: string,
+} | {
+    mode: 'simple',
+};
+export type TypeUtilsData = {
+    importPath: string,
+};
+
+export const toTypescriptCode = (storage: TypedStorage, methods: TypedMethod[], contractName: string, parsedContract: unknown, protocol: { name: string, key: string }, typeAliasData: TypeAliasData, typeUtilsData: TypeUtilsData): TypescriptCodeOutput => {
+    type TypeAlias = { aliasType: string, simpleTypeDefinition: string, simpleTypeImports?: { name: string, isDefault?: boolean, from: string }[] };
+    const usedStrictTypes = [] as TypeAlias[];
+    const addTypeAlias = (strictType: TypeAlias) => {
+        if (!usedStrictTypes.some(x => x.aliasType === strictType.aliasType)) {
+            usedStrictTypes.push(strictType);
+        }
+    };
+
+    // Not really tabs :)
+    const tabs = (indent: number) => Array(indent).fill(`    `).join(``);
+    const toIndentedItems = (indent: number, delimeters: { afterItem?: string, beforeItem?: string }, items: string[]) => {
+        return `
+${tabs(indent + 1)}${items.join(`${delimeters.afterItem ?? ``}
+${tabs(indent + 1)}${delimeters.beforeItem ?? ``}`)}
+${tabs(indent)}`;
+    };
+
+    const typeToCode = (t: TypedType, indent: number): string => {
+        if (t.kind === `value`) {
+            // return `${t.typescriptType}`;
+
+            const prim = `prim` in t.raw ? t.raw.prim : `unknown`;
+
+            // Strict mode
+            if (t.typescriptType === `boolean`
+                || t.typescriptType === `string` && prim === `string`
+            ) {
+                return `${t.typescriptType}`;
+            }
+
+            if (t.typescriptType === 'number') {
+                const simpleBaseType = `string | BigNumber | number`;
+                const typeAlias: TypeAlias = { aliasType: prim, simpleTypeDefinition: `type ${prim} = ${simpleBaseType};`, simpleTypeImports: [{ name: 'BigNumber', isDefault: true, from: 'bignumber.js' }] };
+                addTypeAlias(typeAlias);
+
+                return typeAlias.aliasType;
+            }
+
+            const simpleBaseType = t.typescriptType === 'Date' ? 'Date | string' : t.typescriptType;
+            const typeAlias: TypeAlias = { aliasType: prim, simpleTypeDefinition: `type ${prim} = ${simpleBaseType};` };
+            addTypeAlias(typeAlias);
+
+            return typeAlias.aliasType;
+        }
+        if (t.kind === `array`) {
+            return `Array<${typeToCode(t.array.item, indent)}>`;
+        }
+        if (t.kind === `map`) {
+
+            const typeAlias: TypeAlias = t.map.isBigMap
+                ? { aliasType: `BigMap`, simpleTypeDefinition: 'type BigMap<K, T> = MichelsonMap<K, T>;', simpleTypeImports: [{ name: 'MichelsonMap', from: '@taquito/taquito' }] }
+                : { aliasType: `MMap`, simpleTypeDefinition: 'type MMap<K, T> = MichelsonMap<K, T>;', simpleTypeImports: [{ name: 'MichelsonMap', from: '@taquito/taquito' }] };
+            addTypeAlias(typeAlias);
+
+            return `${typeAlias.aliasType}<${typeToCode(t.map.key, indent)}, ${typeToCode(t.map.value, indent)}>`;
+        }
+        if (t.kind === `object`) {
+            return `{${toIndentedItems(indent, {},
+                t.fields.map((a, i) => varToCode(a, i, indent + 1) + `;`),
+            )}}`;
+        }
+        if (t.kind === `union`) {
+
+            const getUnionItem = (a: TypedVar, i: number) => {
+                const itemCode = `${varToCode(a, i, indent + 1)}`;
+
+                // Keep on single line if already on single line
+                if (!itemCode.includes(`\n`)) {
+                    return `{ ${itemCode} }`;
+                }
+
+                // Indent if multi-line (and remake with extra indent)
+                return `{${toIndentedItems(indent + 1, {}, [`${varToCode(a, i, indent + 2)}`])}}`;
+            };
+
+            return `(${toIndentedItems(indent, { beforeItem: `| ` },
+                t.union.map(getUnionItem),
+            )})`;
+        }
+        if (t.kind === `unit`) {
+            const typeAlias: TypeAlias = { aliasType: `unit`, simpleTypeDefinition: `type unit = (true | undefined);`, };
+            addTypeAlias(typeAlias);
+            return typeAlias.aliasType;
+        }
+        if (t.kind === `never`) {
+            return `never`;
+        }
+        if (t.kind === `unknown`) {
+            return `unknown`;
+        }
+
+        assertExhaustive(t, `Unknown type`);
+        throw new GenerateApiError(`Unknown type node`, { t });
+    };
+
+    const varToCode = (t: TypedVar, i: number, indent: number): string => {
+        return `${t.name ?? i}${t.type.optional ? `?` : ``}: ${typeToCode(t.type, indent)}`;
+    };
+
+    const argsToCode = (args: TypedVar[], indent: number, asObject: boolean): string => {
+        if (args.length === 1) {
+            if (args[0].type.kind === `unit`) { return ``; }
+            return `${args[0].name ?? `param`}: ${typeToCode(args[0].type, indent + 1)}`;
+        }
+
+        const result = `${toIndentedItems(indent, {},
+            args.filter(x => x.name || x.type.kind !== `unit`).map((a, i) => varToCode(a, i, indent + 1) + `,`),
+        )}`;
+
+        if(asObject){
+            return `params: {${result}}`;
+        }
+
+        return result;
+    };
+
+    const methodsToCode = (indent: number) => {
+        const methodFields = methods.map(x => {
+            const methodCode = `${x.name}: (${argsToCode(x.args, indent + 1, false)}) => Promise<void>;`;
+            return methodCode;
+        });
+
+        const methodsTypeCode = `type Methods = {${toIndentedItems(indent, {}, methodFields)}};`;
+        return methodsTypeCode;
+    };
+    const methodsObjectToCode = (indent: number) => {
+        const methodFields = methods.map(x => {
+            const methodCode = `${x.name}: (${argsToCode(x.args, indent + 1, true)}) => Promise<void>;`;
+            return methodCode;
+        });
+
+        const methodsTypeCode = `type MethodsObject = {${toIndentedItems(indent, {}, methodFields)}};`;
+        return methodsTypeCode;
+    };
+
+    const storageToCode = (indent: number) => {
+        const storageTypeCode = `type Storage = ${typeToCode(storage.storage, indent)};`;
+        return storageTypeCode;
+    };
+
+    const methodsCode = methodsToCode(0);
+    const methodsObjectCode = methodsObjectToCode(0);
+    const storageCode = storageToCode(0);
+
+    // Simple type aliases
+    const simpleTypeMappingImportsAll = new Map(usedStrictTypes.map(x => x.simpleTypeImports ?? []).reduce(reduceFlatMap, []).map(x => [`${x?.from}:${x?.name}:${x?.isDefault}`, x]));
+    const simpleTypeMappingImportsFrom = [...simpleTypeMappingImportsAll.values()].reduce((out, x) => {
+        const entry = out[x.from] ?? (out[x.from] = { names: [] });
+        if (x.isDefault) {
+            entry.default = x.name;
+        } else {
+            entry.names.push(x.name);
+        }
+        entry.names.sort((a, b) => a.localeCompare(b));
+        return out;
+    }, {} as { [from: string]: { names: string[], default?: string } });
+
+    const simpleTypeMappingImportsText = Object.keys(simpleTypeMappingImportsFrom)
+        .map(k => {
+            const entry = simpleTypeMappingImportsFrom[k];
+            const items = [entry.default, entry.names.length ? `{ ${entry.names.join(', ')} }` : ''].filter(x => x);
+            return `import ${items.join(', ')} from '${k}';\n`;
+        })
+        .join('');
+
+    const simpleTypeMapping = usedStrictTypes
+        .sort((a, b) => a.aliasType.localeCompare(b.aliasType))
+        .map(x => x.simpleTypeDefinition).join(`\n`);
+
+    const typeUtilsDefinitions =
+            `import { ContractAbstractionFromContractType, WalletContractAbstractionFromContractType } from '${typeUtilsData.importPath}';`;
+
+    const typeAliasesDefinitions =
+        typeAliasData.mode === 'simple' ? `${simpleTypeMappingImportsText}${simpleTypeMapping}`
+            : typeAliasData.mode === 'local' ? typeAliasData.fileContent
+                : `import { ${usedStrictTypes.map(x => x.aliasType).join(`, `)} } from '${typeAliasData.importPath}';`;
+
+    const contractTypeName = `${contractName}ContractType`;
+    const walletTypeName = `${contractName}WalletType`;
+    const codeName = `${contractName}Code`;
+
+    const typesFileContent = `
+${typeUtilsDefinitions}
+${typeAliasesDefinitions}
+
+${storageCode}
+
+${methodsCode}
+
+${methodsObjectCode}
+
+type contractTypes = { methods: Methods, methodsObject: MethodsObject, storage: Storage, code: { __type: '${codeName}', protocol: string, code: object[] } };
+export type ${contractTypeName} = ContractAbstractionFromContractType<contractTypes>;
+export type ${walletTypeName} = WalletContractAbstractionFromContractType<contractTypes>;
+`;
+
+    const contractCodeFileContent = `
+export const ${codeName}: { __type: '${codeName}', protocol: string, code: object[] } = {
+    __type: '${codeName}',
+    protocol: '${protocol.key}',
+    code: JSON.parse(\`${JSON.stringify(parsedContract)}\`)
+};
+`;
+    return {
+        typesFileContent,
+        contractCodeFileContent,
+        storage: storageCode,
+        methods: methodsCode,
+        methodsObject: methodsObjectCode,
+    };
+
+};
+
+

package/src/taquito-contract-type-generator.ts

@@ -0,0 +1,4 @@
+export { generateContractTypesFromMichelsonCode } from './generator/process';
+export { generateContractTypesProcessContractFiles as generateContractTypesProcessTzContractFiles } from './cli-process';
+export { run } from './cli';
+export * from './type-aliases';

package/src/type-aliases-file-content.ts

@@ -0,0 +1,83 @@
+// This is required for copying the type aliases to a local file
+export const typeAliasesFileContent = `
+import { BigNumber } from 'bignumber.js';
+import { MichelsonMap } from '@taquito/taquito';
+
+export type unit = (true | undefined) & { __type: 'unit' };
+
+export type address = string & { __type: 'address' };
+export type bytes = string & { __type: 'bytes' };
+export type contract = string & { __type: 'contract' };
+export type operation = string & { __type: 'operation' };
+export type key = string & { __type: 'key' };
+export type key_hash = string & { __type: 'key_hash' };
+export type signature = string & { __type: 'signature' };
+export type ticket = string & { __type: 'ticket' };
+
+export type timestamp = string & { __type: 'timestamp' };
+
+export type int = BigNumber & { __type: 'int' };
+export type nat = BigNumber & { __type: 'nat' };
+
+export type mutez = BigNumber & { __type: 'mutez' };
+export type tez = BigNumber & { __type: 'tez' };
+
+export type MMap<K, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => V };
+export type BigMap<K, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => Promise<V> };
+
+
+const createStringTypeTas = <T extends string>() => {
+    return (value: string): T => value as T;
+};
+
+const createBigNumberTypeTas = <T extends BigNumber>() => {
+    return (value: number | BigNumber | string): T => new BigNumber(value) as T;
+};
+
+type asMapParamOf<K, V> = K extends string ? { [key: string]: V } | Array<{ key: K, value: V }>
+    : K extends number ? { [key: number]: V } | Array<{ key: K, value: V }>
+    : Array<{ key: K, value: V }>;
+
+function asMap<K, V>(value: asMapParamOf<K, V>): MMap<K, V> {
+    const m = new MichelsonMap<K, V>();
+    if (Array.isArray(value)) {
+        const vArray = value as Array<{ key: K, value: V }>;
+        vArray.forEach(x => m.set(x.key, x.value));
+    } else {
+        const vObject = value as { [key: string]: V };
+        Object.keys(vObject).forEach(key => m.set(key as unknown as K, vObject[key]));
+    }
+    return m as MMap<K, V>;
+}
+const asBigMap = <K, V>(value: asMapParamOf<K, V>) => asMap(value) as unknown as BigMap<K, V>;
+
+function add<T extends BigNumber>(a: T, b: T): T {
+    return a.plus(b) as T;
+}
+function subtract<T extends BigNumber>(a: T, b: T): T {
+    return a.minus(b) as T;
+}
+
+/** tas: Tezos 'as' casting for strict types */
+export const tas = {
+    address: createStringTypeTas<address>(),
+    bytes: createStringTypeTas<bytes>(),
+    contract: createStringTypeTas<contract>(),
+    timestamp: (value: string | Date): timestamp => new Date(value).toISOString() as timestamp,
+
+    int: createBigNumberTypeTas<int>(),
+    nat: createBigNumberTypeTas<nat>(),
+    mutez: createBigNumberTypeTas<mutez>(),
+    tez: createBigNumberTypeTas<tez>(),
+
+    map: asMap,
+    bigMap: asBigMap,
+
+    // Operations
+    add,
+    subtract,
+
+    // To number
+    number: (value: string | BigNumber) => Number(value + ''),
+};
+`;

package/src/type-aliases.ts

@@ -0,0 +1,80 @@
+import { BigNumber } from 'bignumber.js';
+import { MichelsonMap } from '@taquito/taquito';
+
+export type unit = (true | undefined) & { __type: 'unit' };
+
+export type address = string & { __type: 'address' };
+export type bytes = string & { __type: 'bytes' };
+export type contract = string & { __type: 'contract' };
+export type operation = string & { __type: 'operation' };
+export type key = string & { __type: 'key' };
+export type key_hash = string & { __type: 'key_hash' };
+export type signature = string & { __type: 'signature' };
+export type ticket = string & { __type: 'ticket' };
+
+export type timestamp = Date & { __type: 'timestamp' };
+
+export type int = BigNumber & { __type: 'int' };
+export type nat = BigNumber & { __type: 'nat' };
+
+export type mutez = BigNumber & { __type: 'mutez' };
+export type tez = BigNumber & { __type: 'tez' };
+
+export type MMap<K, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => V };
+export type BigMap<K, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => Promise<V> };
+
+
+const createStringTypeTas = <T extends string>() => {
+    return (value: string): T => value as T;
+};
+
+const createBigNumberTypeTas = <T extends BigNumber>() => {
+    return (value: number | BigNumber | string): T => new BigNumber(value) as T;
+};
+
+type asMapParamOf<K, V> = K extends string ? { [key: string]: V } | Array<{ key: K, value: V }>
+    : K extends number ? { [key: number]: V } | Array<{ key: K, value: V }>
+    : Array<{ key: K, value: V }>;
+
+function asMap<K, V>(value: asMapParamOf<K, V>): MMap<K, V> {
+    const m = new MichelsonMap<K, V>();
+    if (Array.isArray(value)) {
+        const vArray = value as Array<{ key: K, value: V }>;
+        vArray.forEach(x => m.set(x.key, x.value));
+    } else {
+        const vObject = value as { [key: string]: V };
+        Object.keys(vObject).forEach(key => m.set(key as unknown as K, vObject[key]));
+    }
+    return m as MMap<K, V>;
+}
+const asBigMap = <K, V>(value: asMapParamOf<K, V>) => asMap(value) as unknown as BigMap<K, V>;
+
+function add<T extends BigNumber>(a: T, b: T): T {
+    return a.plus(b) as T;
+}
+function subtract<T extends BigNumber>(a: T, b: T): T {
+    return a.minus(b) as T;
+}
+
+/** tas: Tezos 'as' casting for strict types */
+export const tas = {
+    address: createStringTypeTas<address>(),
+    bytes: createStringTypeTas<bytes>(),
+    contract: createStringTypeTas<contract>(),
+    timestamp: (value: string | Date): timestamp => new Date(value) as timestamp,
+
+    int: createBigNumberTypeTas<int>(),
+    nat: createBigNumberTypeTas<nat>(),
+    mutez: createBigNumberTypeTas<mutez>(),
+    tez: createBigNumberTypeTas<tez>(),
+
+    map: asMap,
+    bigMap: asBigMap,
+
+    // Operations
+    add,
+    subtract,
+
+    // To number
+    number: (value: string | BigNumber) => Number(value + ''),
+};

package/src/type-utils-file-content.ts

@@ -0,0 +1,38 @@
+// This is required for copying the type utils to a local file
+export const typeUtilsFileContent = `
+import { ContractAbstraction, ContractMethod, ContractMethodObject, ContractProvider, Wallet } from '@taquito/taquito';
+
+type BaseContractType = { methods: unknown, methodsObject: unknown, storage: unknown };
+
+type ContractMethodsOf<T extends ContractProvider | Wallet, TContract extends BaseContractType> = {
+[M in keyof TContract['methods']]:
+TContract['methods'][M] extends (...args: infer A) => unknown
+? (...args: A) => ContractMethod<T>
+: never
+};
+type ContractMethodsObjectsOf<T extends ContractProvider | Wallet, TContract extends BaseContractType> = {
+[M in keyof TContract['methodsObject']]:
+TContract['methodsObject'][M] extends (...args: infer A) => unknown
+? (...args: A) => ContractMethodObject<T>
+: never
+};
+type ContractStorageOf<TContract extends BaseContractType> = TContract['storage'];
+
+export type ContractAbstractionFromContractType<TContract extends BaseContractType> = 
+    ContractAbstraction<ContractProvider, 
+        ContractMethodsOf<ContractProvider, TContract>,
+        ContractMethodsObjectsOf<ContractProvider, TContract>,
+        {},
+        {},
+        ContractStorageOf<TContract>
+    >;
+
+export type WalletContractAbstractionFromContractType<TContract extends BaseContractType> = 
+    ContractAbstraction<Wallet, 
+        ContractMethodsOf<Wallet, TContract>,
+        ContractMethodsObjectsOf<Wallet, TContract>,
+        {},
+        {},
+        ContractStorageOf<TContract>
+    >;
+`;

package/src/type-utils.ts

@@ -0,0 +1,35 @@
+import { ContractAbstraction, ContractMethod, ContractMethodObject, ContractProvider, Wallet } from '@taquito/taquito';
+
+type BaseContractType = { methods: unknown, methodsObject: unknown, storage: unknown };
+
+type ContractMethodsOf<T extends ContractProvider | Wallet, TContract extends BaseContractType> = {
+[M in keyof TContract['methods']]:
+TContract['methods'][M] extends (...args: infer A) => unknown
+? (...args: A) => ContractMethod<T>
+: never
+};
+type ContractMethodsObjectsOf<T extends ContractProvider | Wallet, TContract extends BaseContractType> = {
+[M in keyof TContract['methodsObject']]:
+TContract['methodsObject'][M] extends (...args: infer A) => unknown
+? (...args: A) => ContractMethodObject<T>
+: never
+};
+type ContractStorageOf<TContract extends BaseContractType> = TContract['storage'];
+
+export type ContractAbstractionFromContractType<TContract extends BaseContractType> = 
+    ContractAbstraction<ContractProvider, 
+        ContractMethodsOf<ContractProvider, TContract>,
+        ContractMethodsObjectsOf<ContractProvider, TContract>,
+        {},
+        {},
+        ContractStorageOf<TContract>
+    >;
+
+export type WalletContractAbstractionFromContractType<TContract extends BaseContractType> = 
+    ContractAbstraction<Wallet, 
+        ContractMethodsOf<Wallet, TContract>,
+        ContractMethodsObjectsOf<Wallet, TContract>,
+        {},
+        {},
+        ContractStorageOf<TContract>
+    >;

package/tasks.ts

@@ -0,0 +1,127 @@
+import { SanitizedArgs, ActionResponse, Failure, LikeAPromise, ProxyAction } from "taqueria-sdk/types";
+import glob from 'fast-glob'
+import { join } from 'path'
+import { generateContractTypesProcessContractFiles } from "./src/cli-process";
+
+type PluginOpts = {
+    // TODO: Document these
+    typescriptDir: string,
+    typeAliasMode?: 'local' | 'file' | 'library' | 'simple',
+};
+type Opts = SanitizedArgs & Record<string, unknown>;
+
+const getContractAbspath = (contractFilename: string, parsedArgs: Opts) => 
+    join(parsedArgs.artifactsDir, /\.tz$/.test(contractFilename) ? contractFilename : `${contractFilename}.tz`)
+
+
+const generateContractTypes = (parsedArgs: Opts & PluginOpts) => async (contractFilename: string) : Promise<string> => {
+    const contractAbspath = getContractAbspath(contractFilename, parsedArgs);
+    await generateContractTypesProcessContractFiles({
+        inputTzContractDirectory: parsedArgs.artifactsDir,
+        inputFiles: [contractAbspath],
+        outputTypescriptDirectory: parsedArgs.typescriptDir,
+        format: 'tz',
+        typeAliasMode: parsedArgs.typeAliasMode ?? 'file',
+    });
+
+    return `${contractFilename}: Types generated`;
+
+    // TODO: Generate contract michelson
+    // TODO: Generate types from michelson
+    
+    // throw new Error('Not Implemented');
+
+    // // TODO: Should getting the default environment be provided by the SDK or the framework?
+    // const currentEnv = parsedArgs.env
+    //     ? (parsedArgs.env as string)
+    //     : (
+    //         parsedArgs.config.environment
+    //             ? parsedArgs.config.environment.default
+    //             : 'development'
+    //     )
+    // const env = parsedArgs.config.environment && parsedArgs.config.environment[currentEnv]
+    //         ? parsedArgs.config.environment[currentEnv]
+    //         : undefined
+            
+    // // Has storage been provided for this contract?
+    // if (env && env.storage) {
+    //     try {
+    //         const tezos = new TezosToolkit(env.rpcUrl)
+    //         const contractData = await readFile(contractAbspath, "utf-8")
+
+    //         // TODO: Generate contract michelson
+    //         // TODO: Generate types from michelson
+
+    //         throw new Error('Not Implemented');
+    //         // await importKey(tezos, env.faucet.email, env.faucet.password, env.faucet.mnemonic.join(' '), env.faucet.activation_code)
+    //         // return tezos.contract.originate({
+    //         //     code: contractData,
+    //         //     storage: env.storage[contractFilename]
+    //         // })
+    //         // .then(operation => `${contractFilename}: ${operation.contractAddress}`)
+    //     }
+    //     catch (err) {
+    //         return Promise.reject({
+    //             status: 'failed',
+    //             stdout: "",
+    //             stderr: err
+    //         })
+    //     }
+    // }
+
+    // return Promise.reject({
+    //     status: 'failed',
+    //     stderr: `No storage configured in your configuration file for ${contractFilename}`,
+    //     stdout: ""
+    // })
+}
+
+const generateContractTypesAll = (parsedArgs: Opts & PluginOpts) : Promise<string[]> =>
+    glob("**/*.tz", {cwd: parsedArgs.artifactsDir})
+    .then(files => Promise.all(files.map(generateContractTypes(parsedArgs))))
+
+export const generateTypes = <T>(parsedArgs: Opts): LikeAPromise<ActionResponse, Failure<T>> => {
+    if(!parsedArgs.typescriptDir){
+        return Promise.reject({
+            status: 'failed',
+            stderr: `No typescriptDir configured`,
+            stdout: ""
+        });
+    }
+
+    // WORKAROUND: Redirect console.log
+    const strOutLog = [] as string[];
+    const consoleLogOrig = console.log;
+    console.log = (message:string, data?:unknown) => {
+        strOutLog.push(`${message}${data?`\n${JSON.stringify(data,null,2)}`:''}`);
+    }
+    console.log('generateTypes', { 
+        typescriptDir: parsedArgs.typescriptDir
+    });
+
+    // console.log = consoleLogOrig;
+    // return Promise.resolve({
+    //     status: 'success',
+    //     stdout: `${strOutLog.join('\n')}`,
+    //     stderr: ""
+    // });
+
+    const argsTyped = parsedArgs as Opts & PluginOpts;
+
+    const p = argsTyped.contract
+        ? generateContractTypes(argsTyped) (argsTyped.contract as string)
+        : generateContractTypesAll(argsTyped)
+
+    return p.then(data => {
+        console.log = consoleLogOrig;
+        return ({
+            status: 'success',
+            stdout: `${strOutLog.join('\n')}${Array.isArray(data) ? data.join("\n") : data}`,
+            stderr: ""
+        });
+    })
+}
+
+export const tasks = {
+    generateTypes,
+} 

package/test/generator.spec.ts

@@ -0,0 +1,69 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { promisify } from 'util';
+import { generateContractTypesFromMichelsonCode } from '../src/generator/process';
+import { normalizeContractName } from '../src/generator/contract-name';
+import { TypeAliasData } from '../src/generator/typescript-output';
+
+
+const readFileText = async (filePath: string): Promise<string> => {
+    return fs.readFile(filePath, { encoding: 'utf8' });
+};
+
+describe('Generate Example Contracts', () => {
+
+    const typeAliasDataLibrary: TypeAliasData = { mode: 'library', importPath: '@taquito/contract-type-generator' };
+    const typeAliasDataSimple: TypeAliasData = { mode: 'simple' };
+
+    const exampleDir = path.resolve(__dirname, `../example`);
+
+    const testContractTypeGeneration = async (contractFileName: string, format: 'tz' | 'json', mode: 'library' | 'simple') => {
+        const contractRaw = await readFileText(`${exampleDir}/contracts/${contractFileName}.${format}`);
+        const expectedTypeFileContent = await readFileText(`${exampleDir}/types${mode === 'simple' ? '-simple' : ''}/${contractFileName}.types.ts`);
+        const expectedCodeFileContent = await readFileText(`${exampleDir}/types${mode === 'simple' ? '-simple' : ''}/${contractFileName}.code.ts`);
+        const contractName = normalizeContractName(contractFileName);
+        const typeAliasData = mode === 'library' ? typeAliasDataLibrary : typeAliasDataSimple;
+        const { typescriptCodeOutput: { typesFileContent: actualTypesFileContent, contractCodeFileContent: actualCodeFileContent } } = generateContractTypesFromMichelsonCode(contractRaw, contractName, format, typeAliasData);
+        expect(actualTypesFileContent.trim()).toEqual(expectedTypeFileContent.trim());
+        expect(actualCodeFileContent.trim()).toEqual(expectedCodeFileContent.trim());
+    };
+
+    it('Generate Types 01 - tz library', async () => {
+        await testContractTypeGeneration('example-contract-1', 'tz', 'library');
+    });
+    it('Generate Types 01 - tz simple', async () => {
+        await testContractTypeGeneration('example-contract-1', 'tz', 'simple');
+    });
+    it('Generate Types 02 - tz library', async () => {
+        await testContractTypeGeneration('example-contract-2', 'tz', 'library');
+    });
+    it('Generate Types 02 - tz simple', async () => {
+        await testContractTypeGeneration('example-contract-2', 'tz', 'simple');
+    });
+
+    it('Generate Types 03 - json library', async () => {
+        await testContractTypeGeneration('example-contract-3', 'json', 'library');
+    });
+
+    it('Generate Types 04 - newer protocol', async () => {
+        await testContractTypeGeneration('example-contract-4', 'tz', 'library');
+    });
+    it('Generate Types 04 - tz simple', async () => {
+        await testContractTypeGeneration('example-contract-4', 'tz', 'simple');
+    });
+
+    // it(`Generate Types - All`, async () => {
+    //     const allExampleContracts = (await fs.readdir(`${exampleDir}/contracts/`)).filter(f=>f.endsWith('.tz') || f.endsWith('.json'));
+
+    //     for(const f of allExampleContracts){
+    //         const fRelative = f.replace(exampleDir,'');
+    //         const m = fRelative.match(/^(.*)\.(tz|json)$/);
+    //         if(!m){ return; }
+    //         const [_,filename, ext] = m;
+
+    //         await testContractTypeGeneration(filename, ext as 'tz'|'json', 'simple');
+    //     }
+    // });
+
+
+});