@taqueria/plugin-contract-types 0.3.0 → 0.4.0-rc2

package/src/type-utils.ts

@@ -1,35 +1,33 @@
 import { ContractAbstraction, ContractMethod, ContractMethodObject, ContractProvider, Wallet } from '@taquito/taquito';
 
-type BaseContractType = { methods: unknown, methodsObject: unknown, storage: unknown };
+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
+	[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
+	[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 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>
-    >;
+export type WalletContractAbstractionFromContractType<TContract extends BaseContractType> = ContractAbstraction<
+	Wallet,
+	ContractMethodsOf<Wallet, TContract>,
+	ContractMethodsObjectsOf<Wallet, TContract>,
+	{},
+	{},
+	ContractStorageOf<TContract>
+>;

package/tasks.ts

@@ -1,60 +1,56 @@
-import { SanitizedArgs, PluginResponse, Failure, LikeAPromise } from "@taqueria/node-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`;
+import { LikeAPromise, PluginResponse, RequestArgs, TaqError } from '@taqueria/node-sdk/types';
+import glob from 'fast-glob';
+import { join } from 'path';
+import { generateContractTypesProcessContractFiles } from './src/cli-process';
+interface Opts extends RequestArgs.ProxyRequestArgs {
+	// TODO: Document these
+	typescriptDir?: string;
+	typeAliasMode?: 'local' | 'file' | 'library' | 'simple';
+	contract?: string;
 }
 
-const generateContractTypesAll = async (parsedArgs: Opts & PluginOpts) : Promise<string[]> => {
-    const files = await glob("**/*.tz", {cwd: parsedArgs.artifactsDir});
-    return await Promise.all(files.map(generateContractTypes(parsedArgs)));
-}
-
-export const generateTypes = <T>(parsedArgs: Opts): LikeAPromise<PluginResponse, Failure<T>> => {
-    debugger
-    parsedArgs.typescriptDir = parsedArgs.typescriptDir || 'types';
+const getContractAbspath = (contractFilename: string, parsedArgs: Opts) =>
+	join(parsedArgs.config.artifactsDir, /\.tz$/.test(contractFilename) ? contractFilename : `${contractFilename}.tz`);
+
+const generateContractTypes = (parsedArgs: Opts) =>
+	async (contractFilename: string): Promise<string> => {
+		const contractAbspath = getContractAbspath(contractFilename, parsedArgs);
+		await generateContractTypesProcessContractFiles({
+			inputTzContractDirectory: parsedArgs.config.artifactsDir,
+			inputFiles: [contractAbspath],
+			outputTypescriptDirectory: parsedArgs.typescriptDir || 'types',
+			format: 'tz',
+			typeAliasMode: parsedArgs.typeAliasMode ?? 'file',
+		});
+
+		return `${contractFilename}: Types generated`;
+	};
+
+const generateContractTypesAll = async (parsedArgs: Opts): Promise<string[]> => {
+	const files = await glob('**/*.tz', { cwd: parsedArgs.config.artifactsDir });
+	return await Promise.all(files.map(generateContractTypes(parsedArgs)));
+};
 
-    console.log('generateTypes', { 
-        typescriptDir: parsedArgs.typescriptDir
-    });
+export const generateTypes = (parsedArgs: Opts): LikeAPromise<PluginResponse, TaqError.t> => {
+	parsedArgs.typescriptDir = parsedArgs.typescriptDir || 'types';
 
-    const argsTyped = parsedArgs as Opts & PluginOpts;
+	console.log('generateTypes', {
+		typescriptDir: parsedArgs.typescriptDir,
+	});
 
-    const p = argsTyped.contract
-        ? generateContractTypes(argsTyped) (argsTyped.contract as string)
-        : generateContractTypesAll(argsTyped)
+	const p = parsedArgs.contract
+		? generateContractTypes(parsedArgs)(parsedArgs.contract)
+		: generateContractTypesAll(parsedArgs);
 
-    return p.then(data => {
-        console.log(
-            (Array.isArray(data))
-            ? data.join("\n")
-            : data
-        )
-    })
-}
+	return p.then(data => {
+		console.log(
+			(Array.isArray(data))
+				? data.join('\n')
+				: data,
+		);
+	});
+};
 
 export const tasks = {
-    generateTypes,
-} 
+	generateTypes,
+};

package/test/generator.spec.ts

@@ -1,69 +1,79 @@
 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';
-
+import { generateContractTypesFromMichelsonCode } from '../src/generator/process';
+import { TypeAliasData, TypeUtilsData } from '../src/generator/typescript-output';
 
 const readFileText = async (filePath: string): Promise<string> => {
-    return fs.readFile(filePath, { encoding: 'utf8' });
+	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 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');
-    });
+	const exampleDir = path.resolve(__dirname, `../example`);
 
-    it('Generate Types 03 - json library', async () => {
-        await testContractTypeGeneration('example-contract-3', 'json', 'library');
-    });
+	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 typeUtilsData: TypeUtilsData = { importPath: `./type-utils` };
+		const {
+			typescriptCodeOutput: {
+				typesFileContent: actualTypesFileContent,
+				contractCodeFileContent: actualCodeFileContent,
+			},
+		} = generateContractTypesFromMichelsonCode(contractRaw, contractName, format, typeAliasData, typeUtilsData);
+		expect(actualTypesFileContent.trim()).toEqual(expectedTypeFileContent.trim());
+		expect(actualCodeFileContent.trim()).toEqual(expectedCodeFileContent.trim());
+	};
 
-    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 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 - All`, async () => {
-    //     const allExampleContracts = (await fs.readdir(`${exampleDir}/contracts/`)).filter(f=>f.endsWith('.tz') || f.endsWith('.json'));
+	it('Generate Types 03 - json library', async () => {
+		await testContractTypeGeneration('example-contract-3', 'json', 'library');
+	});
 
-    //     for(const f of allExampleContracts){
-    //         const fRelative = f.replace(exampleDir,'');
-    //         const m = fRelative.match(/^(.*)\.(tz|json)$/);
-    //         if(!m){ return; }
-    //         const [_,filename, ext] = m;
+	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');
+	});
 
-    //         await testContractTypeGeneration(filename, ext as 'tz'|'json', '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');
+	//     }
+	// });
 });

package/tsconfig.json

@@ -1,13 +1,13 @@
 {
-  "compilerOptions": {
-    "target": "ES6",
-    "module": "CommonJS",
-    "declaration": true,
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "lib",
-  }
-}
+	"compilerOptions": {
+		"target": "ES2021",
+		"module": "CommonJS",
+		"declaration": true,
+		"allowSyntheticDefaultImports": true,
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"strict": true,
+		"skipLibCheck": true,
+		"outDir": "lib"
+	}
+}

package/Readme.md

@@ -1,212 +0,0 @@
-This plugin will generate typescript types for a contract.
-
-In the simple case, it reads the `artifacts` folder for any `*.tz` Michelson files and will generate a types file with the matching filename for each.
-
-## Requirements
-
-This is using a unmerged taquito PR:
-
-- https://github.com/ecadlabs/taquito/pull/1343
-    - `npm i @taquito/taquito@11.1.0-6bfb6c08--1343 --registry https://npm.preview.tezostaquito.io/`
-
-## Examples
-
-### Example Usage (based on an nft auction contract from open minter sdk)
-
-```ts
-export const exampleContractMethods1 = async () => {
-
-    const Tezos = new TezosToolkit(`https://YOUR_PREFERRED_RPC_URL`)
-
-    const contract = await Tezos.contract.at<TestContract>(`tz123`);
-
-    contract.methods.bid(tas.nat(0));
-    contract.methods.configure(
-        /*opening_price:*/ tas.mutez(10),
-        /*min_raise_percent:*/ tas.nat(10),
-        /*min_raise:*/ tas.mutez(10),
-        /*round_time:*/ tas.nat(10),
-        /*extend_time:*/ tas.nat(10),
-        /*asset:*/ [{
-            fa2_address: tas.address(`tz123`),
-            fa2_batch: [{
-                amount: tas.nat(100),
-                token_id: tas.nat(`100000000000000`),
-            }],
-        }],
-        /*start_time:*/ tas.timestamp(new Date()),
-        /*end_time:*/ tas.timestamp(`2020-01-01`),
-    );
-
-    // methodsObject
-    contract.methodsObject.bid(tas.nat(0));
-    contract.methodsObject.configure({
-        asset: [{
-            fa2_address: tas.address(`tz123`),
-            fa2_batch: [{
-                amount: tas.nat(100),
-                token_id: tas.nat(`100000000000000`),
-            }],
-        }],
-        start_time: tas.timestamp(new Date()),
-        end_time: tas.timestamp(`2020-01-01`),
-        extend_time: tas.nat(10),
-        min_raise: tas.mutez(10),
-        min_raise_percent: tas.nat(10),
-        opening_price: tas.mutez(10),
-        round_time: tas.nat(10),
-    });
-
-};
-```
-
-
-### Example typegen task
-
-```console
-$ taqueria typegen --typescriptDir ./types
-generateTypes
-{
-  "typescriptDir": "./types"
-}
-Generating Types: /home/rick/projects/crypto/taqueria/example/artifacts => /home/rick/projects/crypto/taqueria/example/types
-Contracts Found:
-        - /home/rick/projects/crypto/taqueria/example/artifacts/example-contract-1.tz
-Processing /example-contract-1.tz...example-contract-1.tz: Types generated
-```
-
-
-### Example type output
-
-```ts
-type Storage = {
-    pauseable_admin?: {
-        admin: address;
-        paused: boolean;
-        pending_admin?: address;
-    };
-    current_id: nat;
-    max_auction_time: nat;
-    max_config_to_start_time: nat;
-    auctions: BigMap<nat, {
-        seller: address;
-        current_bid: mutez;
-        start_time: timestamp;
-        last_bid_time: timestamp;
-        round_time: int;
-        extend_time: int;
-        asset: Array<{
-            fa2_address: address;
-            fa2_batch: Array<{
-                token_id: nat;
-                amount: nat;
-            }>;
-        }>;
-        min_raise_percent: nat;
-        min_raise: mutez;
-        end_time: timestamp;
-        highest_bidder: address;
-    }>;
-};
-
-type Methods = {
-    confirm_admin: () => Promise<void>;
-    pause: (param: boolean) => Promise<void>;
-    set_admin: (param: address) => Promise<void>;
-    bid: (param: nat) => Promise<void>;
-    cancel: (param: nat) => Promise<void>;
-    configure: (
-        opening_price: mutez,
-        min_raise_percent: nat,
-        min_raise: mutez,
-        round_time: nat,
-        extend_time: nat,
-        asset: Array<{
-            fa2_address: address;
-            fa2_batch: Array<{
-                token_id: nat;
-                amount: nat;
-            }>;
-        }>,
-        start_time: timestamp,
-        end_time: timestamp,
-    ) => Promise<void>;
-    resolve: (param: nat) => Promise<void>;
-};
-```
-
-
-## Taquito library changes
-
-See [example-usage.ts](example/example-usage.ts) for full example
-
-### Before
-
-Using taquito with the generated contract types:
-
-The at method can be called providing a type with a utility method that can be provided:
-```ts 
-const contract = await Tezos.contract.at(`tz123`, contractAbstractionComposer<TestContractType>());
-
-// methods can now use typed parameters
-// methodsObject will be able to use type parameters
-```
-
-This can work the same with a wallet
-```ts 
-const contract = await Tezos.wallet.at(`tz123`, walletAbstractionComposer<TestContractType>());
-```
-
-Alternatively, this can be done with a cast:
-```ts
-const contract = await Tezos.contract.at(`tz123`) as ContractProviderFromContractType<TestContractType>;
-```
-
-
-The originate contract does not have any way to provide a type, so this requires a cast:
-```ts
-const originationResult = await Tezos.contract.originate({...});
-const contract = await originationResult.contract(5) as ContractProviderFromContractType<TestContractType2>;
-```
-
-
-For accessing storage, there is no way to pass the type through the contract class, 
-so it requires providing the type again:
-```ts
-const contract = await Tezos.contract.at(`tz123`) as ContractProviderFromContractType<TestContractType>;
-const storage = await contract.storage<StorageFromContractType<TestContractType>>();
-```
-
-
-### After
-
-Extending ContractAbstraction with additional generic types:
-
-The at method can be called with the contract type provided:
-```ts 
-const contract = await Tezos.contract.at<TestContract>(`tz123`);
-
-// methods can now use typed parameters
-// methodsObject will be able to use type parameters
-// storage will be able to use type parameters
-
-```
-
-This can work the same with a wallet
-```ts 
-const contract = await Tezos.wallet.at<TestWalletContract>(`tz123`);
-```
-
-The originate contract now accepts a type:
-```ts
-const originationResult = await Tezos.contract.originate({...});
-const contract = await originationResult.contract<TestContract2>(5);
-```
-
-
-The contract type now also provides the default storage type:
-```ts
-const contract = await Tezos.contract.at<TestContract>(`tz123`);
-const storage = await contract.storage();
-```
-