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

package/src/generator/typescript-output.ts

@@ -1,210 +1,246 @@
 import { assertExhaustive, GenerateApiError, reduceFlatMap } from './common';
-import { TypedStorage, TypedMethod, TypedType, TypedVar } from './contract-parser';
+import { TypedMethod, TypedStorage, TypedType, TypedVar } from './contract-parser';
 
 export type TypescriptCodeOutput = {
-    typesFileContent: string;
-    contractCodeFileContent: string;
-    storage: string;
-    methods: string;
-    methodsObject: string;
+	typesFileContent: string;
+	contractCodeFileContent: string;
+	storage: string;
+	methods: string;
+	methodsObject: string;
 };
 
 export type TypeAliasData = {
-    mode: 'local',
-    fileContent?: string,
+	mode: 'local';
+	fileContent?: string;
 } | {
-    mode: 'file' | 'library',
-    importPath?: string,
+	mode: 'file' | 'library';
+	importPath?: string;
 } | {
-    mode: 'simple',
+	mode: 'simple';
 };
 export type TypeUtilsData = {
-    importPath: string,
+	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 ?? ``}`)}
+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, numberVarNamePrefix = ''): string => {
-        return `${t.name ?? `${numberVarNamePrefix}${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, asObject ? '' : '_') + `,`),
-        )}`;
-
-        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 = `
+	};
+
+	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, numberVarNamePrefix = ''): string => {
+		return `${t.name ?? `${numberVarNamePrefix}${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, asObject ? '' : '_') + `,`
+				),
+			)
+		}`;
+
+		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}
 
@@ -219,21 +255,18 @@ export type ${contractTypeName} = ContractAbstractionFromContractType<contractTy
 export type ${walletTypeName} = WalletContractAbstractionFromContractType<contractTypes>;
 `;
 
-    const contractCodeFileContent = `
+	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,
-    };
-
+	return {
+		typesFileContent,
+		contractCodeFileContent,
+		storage: storageCode,
+		methods: methodsCode,
+		methodsObject: methodsObjectCode,
+	};
 };
-
-

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

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

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

@@ -26,6 +26,8 @@ type MapKey = Array<any> | object | string | boolean | number;
 export type MMap<K extends MapKey, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => V };
 export type BigMap<K extends MapKey, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => Promise<V> };
 
+export type chest = string & { __type: 'chest' };
+export type chest_key = string & { __type: 'chest_key' };
 
 const createStringTypeTas = <T extends string>() => {
     return (value: string): T => value as T;
@@ -64,6 +66,8 @@ export const tas = {
     address: createStringTypeTas<address>(),
     bytes: createStringTypeTas<bytes>(),
     contract: createStringTypeTas<contract>(),
+    chest: createStringTypeTas<chest>(),
+    chest_key: createStringTypeTas<chest_key>(),
     timestamp: (value: string | Date): timestamp => new Date(value).toISOString() as timestamp,
 
     int: createBigNumberTypeTas<int>(),
@@ -81,4 +85,4 @@ export const tas = {
     // To number
     number: (value: string | BigNumber) => Number(value + ''),
 };
-`;
+`;

package/src/type-aliases.ts

@@ -1,5 +1,5 @@
-import { BigNumber } from 'bignumber.js';
 import { MichelsonMap } from '@taquito/taquito';
+import { BigNumber } from 'bignumber.js';
 
 export type unit = (true | undefined) & { __type: 'unit' };
 
@@ -24,58 +24,62 @@ type MapKey = Array<any> | object | string | boolean | number;
 export type MMap<K extends MapKey, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => V };
 export type BigMap<K extends MapKey, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => Promise<V> };
 
+export type chest = string & { __type: 'chest' };
+export type chest_key = string & { __type: 'chest_key' };
 
 const createStringTypeTas = <T extends string>() => {
-    return (value: string): T => value as T;
+	return (value: string): T => value as T;
 };
 
 const createBigNumberTypeTas = <T extends BigNumber>() => {
-    return (value: number | BigNumber | string): T => new BigNumber(value) as T;
+	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 }>;
+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 extends MapKey, 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 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 extends MapKey, 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;
+	return a.plus(b) as T;
 }
 function subtract<T extends BigNumber>(a: T, b: T): T {
-    return a.minus(b) as 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 + ''),
+	address: createStringTypeTas<address>(),
+	bytes: createStringTypeTas<bytes>(),
+	contract: createStringTypeTas<contract>(),
+	chest: createStringTypeTas<chest>(),
+	chest_key: createStringTypeTas<chest_key>(),
+	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-utils-file-content.ts

@@ -35,4 +35,4 @@ export type WalletContractAbstractionFromContractType<TContract extends BaseCont
         {},
         ContractStorageOf<TContract>
     >;
-`;
+`;