From 1ce66b4a81b736f5288463be609a902af64cbe77 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 5 Dec 2017 19:53:59 +0300 Subject: Rename abi-gen to typed-contracts --- packages/abi-gen/src/globals.d.ts | 4 ++ packages/abi-gen/src/index.ts | 98 +++++++++++++++++++++++++++++++++++++++ packages/abi-gen/src/types.ts | 15 ++++++ packages/abi-gen/src/utils.ts | 56 ++++++++++++++++++++++ 4 files changed, 173 insertions(+) create mode 100644 packages/abi-gen/src/globals.d.ts create mode 100644 packages/abi-gen/src/index.ts create mode 100644 packages/abi-gen/src/types.ts create mode 100644 packages/abi-gen/src/utils.ts (limited to 'packages/abi-gen/src') diff --git a/packages/abi-gen/src/globals.d.ts b/packages/abi-gen/src/globals.d.ts new file mode 100644 index 000000000..39df3f852 --- /dev/null +++ b/packages/abi-gen/src/globals.d.ts @@ -0,0 +1,4 @@ +declare function toSnakeCase(str: string): string; +declare module 'to-snake-case' { + export = toSnakeCase; +} diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts new file mode 100644 index 000000000..19d289e49 --- /dev/null +++ b/packages/abi-gen/src/index.ts @@ -0,0 +1,98 @@ +#!/usr/bin/env node + +import chalk from 'chalk'; +import * as fs from 'fs'; +import {sync as globSync} from 'glob'; +import * as Handlebars from 'handlebars'; +import * as _ from 'lodash'; +import * as mkdirp from 'mkdirp'; +import * as yargs from 'yargs'; + +import toSnakeCase = require('to-snake-case'); +import * as Web3 from 'web3'; + +import {ContextData, ParamKind} from './types'; +import {utils} from './utils'; + +const ABI_TYPE_METHOD = 'function'; +const MAIN_TEMPLATE_NAME = 'contract.mustache'; + +const args = yargs + .option('abiGlob', { + describe: 'Glob pattern to search for ABI JSON files', + type: 'string', + demand: true, + }) + .option('templates', { + describe: 'Folder where to search for templates', + type: 'string', + demand: true, + }) + .option('output', { + describe: 'Folder where to put the output files', + type: 'string', + demand: true, + }) + .argv; + +function writeOutputFile(name: string, renderedTsCode: string): void { + const fileName = toSnakeCase(name); + const filePath = `${args.output}/${fileName}.ts`; + fs.writeFileSync(filePath, renderedTsCode); + utils.log(`Created: ${chalk.bold(filePath)}`); +} + +Handlebars.registerHelper('parameterType', utils.solTypeToTsType.bind(utils, ParamKind.Input)); +Handlebars.registerHelper('returnType', utils.solTypeToTsType.bind(utils, ParamKind.Output)); +const partialTemplateFileNames = globSync(`${args.templates}/partials/**/*.mustache`); +for (const partialTemplateFileName of partialTemplateFileNames) { + const namedContent = utils.getNamedContent(partialTemplateFileName); + Handlebars.registerPartial(namedContent.name, namedContent.content); +} + +const mainTemplate = utils.getNamedContent(`${args.templates}/${MAIN_TEMPLATE_NAME}`); +const template = Handlebars.compile(mainTemplate.content); +const abiFileNames = globSync(args.abiGlob); +if (_.isEmpty(abiFileNames)) { + utils.log(`${chalk.red(`No ABI files found.`)}`); + utils.log(`Please make sure you've passed the correct folder name and that the files have + ${chalk.bold('*.json')} extensions`); + process.exit(1); +} else { + utils.log(`Found ${chalk.green(`${abiFileNames.length}`)} ${chalk.bold('ABI')} files`); + mkdirp.sync(args.output); +} +for (const abiFileName of abiFileNames) { + const namedContent = utils.getNamedContent(abiFileName); + utils.log(`Processing: ${chalk.bold(namedContent.name)}...`); + const parsedContent = JSON.parse(namedContent.content); + const ABI = _.isArray(parsedContent) ? + parsedContent : // ABI file + parsedContent.abi; // Truffle contracts file + if (_.isUndefined(ABI)) { + utils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`); + utils.log(`Please make sure your ABI file is either an array with ABI entries or an object with the abi key`); + process.exit(1); + } + const methodAbis = ABI.filter((abi: Web3.AbiDefinition) => abi.type === ABI_TYPE_METHOD) as Web3.MethodAbi[]; + const methodsData = _.map(methodAbis, methodAbi => { + _.map(methodAbi.inputs, input => { + if (_.isEmpty(input.name)) { + // Auto-generated getters don't have parameter names + input.name = 'index'; + } + }); + // This will make templates simpler + const methodData = { + ...methodAbi, + singleReturnValue: methodAbi.outputs.length === 1, + }; + return methodData; + }); + const contextData = { + contractName: namedContent.name, + methods: methodsData, + }; + const renderedTsCode = template(contextData); + writeOutputFile(namedContent.name, renderedTsCode); +} diff --git a/packages/abi-gen/src/types.ts b/packages/abi-gen/src/types.ts new file mode 100644 index 000000000..1dc039c83 --- /dev/null +++ b/packages/abi-gen/src/types.ts @@ -0,0 +1,15 @@ +import * as Web3 from 'web3'; + +export enum ParamKind { + Input = 'input', + Output = 'output', +} + +export interface Method extends Web3.MethodAbi { + singleReturnValue: boolean; +} + +export interface ContextData { + contractName: string; + methods: Method[]; +} diff --git a/packages/abi-gen/src/utils.ts b/packages/abi-gen/src/utils.ts new file mode 100644 index 000000000..eaf5a30cc --- /dev/null +++ b/packages/abi-gen/src/utils.ts @@ -0,0 +1,56 @@ +import * as fs from 'fs'; +import * as _ from 'lodash'; +import * as path from 'path'; + +import {ParamKind} from './types'; + +export const utils = { + solTypeToTsType(paramKind: ParamKind, solType: string): string { + const trailingArrayRegex = /\[\d*\]$/; + if (solType.match(trailingArrayRegex)) { + const arrayItemSolType = solType.replace(trailingArrayRegex, ''); + const arrayItemTsType = utils.solTypeToTsType(paramKind, arrayItemSolType); + const arrayTsType = `${arrayItemTsType}[]`; + return arrayTsType; + } else { + const solTypeRegexToTsType = [ + {regex: '^string$', tsType: 'string'}, + {regex: '^address$', tsType: 'string'}, + {regex: '^bool$', tsType: 'boolean'}, + {regex: '^u?int\\d*$', tsType: 'BigNumber'}, + {regex: '^bytes\\d*$', tsType: 'string'}, + ]; + if (paramKind === ParamKind.Input) { + // web3 allows to pass those an non-bignumbers and that's nice + // but it always returns stuff as BigNumbers + solTypeRegexToTsType.unshift({regex: '^u?int(8|16|32)?$', tsType: 'number|BigNumber'}); + } + for (const regexAndTxType of solTypeRegexToTsType) { + const {regex, tsType} = regexAndTxType; + if (solType.match(regex)) { + return tsType; + } + } + throw new Error(`Unknown Solidity type found: ${solType}`); + } + }, + log(...args: any[]): void { + console.log(...args); // tslint:disable-line:no-console + }, + getPartialNameFromFileName(filename: string): string { + const name = path.parse(filename).name; + return name; + }, + getNamedContent(filename: string): {name: string; content: string} { + const name = utils.getPartialNameFromFileName(filename); + try { + const content = fs.readFileSync(filename).toString(); + return { + name, + content, + }; + } catch (err) { + throw new Error(`Failed to read ${filename}: ${err}`); + } + }, +}; -- cgit v1.2.3